def test_dataclasses_todict(self):
a = 1
b = random_string()
c = {random_string(): random_string()}
a1 = self.A(a=a, b=b, c=c)
self.assertDictEqual(a1.dict(), {"a": a, "b": b, "c": c, "d": self.A.d})
def test_dataclasses_init(self):
a = 1
b = random_string()
c = {random_string(): random_string()}
a1 = self.A(a=a, b=b, c=c)
self.assertEqual(a1.a, a)
self.assertEqual(a1.b, b)
self.assertEqual(a1.c, c)
self.assertEqual(a1.d, self.A.d)
def test_unexpected_key(self):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
random_key = random_string()
self.A(a=2, b="asd", c={}, **{random_key: random_string()})
self.assertEqual(f"Got an unexpected key {random_key}", str(w[-1].message))
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
random_key = random_string()
a1 = self.A(a=2, b="asd", c={})
setattr(a1, random_key, random_string())
self.assertEqual(f"Got an unexpected key {random_key}", str(w[-1].message))
def _request(self, method, url_or_endpoint, **kwargs):
if not url_or_endpoint.startswith(("http://", "https://")):
api_base_url = kwargs.pop("api_base_url", self.API_BASE_URL)
url = "{base}{endpoint}".format(base=api_base_url, endpoint=url_or_endpoint)
else:
url = url_or_endpoint
if isinstance(kwargs.get("data", ""), dict):
data = optionaldict(kwargs["data"])
if "mchid" not in data:
# F**k Tencent
data.setdefault("mch_id", self.mch_id)
data.setdefault("sub_mch_id", self.sub_mch_id)
data.setdefault("nonce_str", random_string(32))
sign = calculate_signature(data, self.api_key)
body = dict_to_xml(data, sign)
body = body.encode("utf-8")
kwargs["data"] = body
# 商户证书
if self.mch_cert and self.mch_key:
kwargs["cert"] = (self.mch_cert, self.mch_key)
res = requests.request(method=method, url=url, **kwargs)
try:
res.raise_for_status()
except requests.RequestException as reqe:
raise WeChatPayException(return_code=None, client=self, request=reqe.request, response=reqe.response)
return self._handle_result(res)
def get_subscribe_authorize_url(self, scene, template_id, redirect_url, reserved=None):
"""
构造请求用户授权的url
详情请参阅：
https://mp.weixin.qq.com/wiki?id=mp1500374289_66bvB
:param scene: 订阅场景值，开发者可以填0-10000的整形值，用来标识订阅场景值
:type scene: int
:param template_id: 订阅消息模板ID，登录公众平台后台，在接口权限列表处可查看订阅模板ID
:param redirect_url: 授权后重定向的回调地址
:param reserved: 用于保持请求和回调的状态，授权请后原样带回给第三方。该参数可用于防止csrf攻击。若不指定则随机生成。
"""
if reserved is None:
reserved = random_string()
base_url = "https://mp.weixin.qq.com/mp/subscribemsg"
params = [
("action", "get_confirm"),
("appid", self.appid),
("scene", scene),
("template_id", template_id),
("redirect_url", redirect_url),
("reserved", reserved),
]
encoded_params = urlencode(params)
return f"{base_url}?{encoded_params}#wechat_redirect"
def get_subscribe_authorize_url(self,
scene,
template_id,
redirect_url,
reserved=None):
"""
构造请求用户授权的url
详情请参阅：
https://mp.weixin.qq.com/wiki?id=mp1500374289_66bvB
:param scene: 订阅场景值，开发者可以填0-10000的整形值，用来标识订阅场景值
:type scene: int
:param template_id: 订阅消息模板ID，登录公众平台后台，在接口权限列表处可查看订阅模板ID
:param redirect_url: 授权后重定向的回调地址
:param reserved: 用于保持请求和回调的状态，授权请后原样带回给第三方。该参数可用于防止csrf攻击。若不指定则随机生成。
"""
if reserved is None:
reserved = random_string()
base_url = 'https://mp.weixin.qq.com/mp/subscribemsg'
params = [
('action', 'get_confirm'),
('appid', self.appid),
('scene', scene),
('template_id', template_id),
('redirect_url', redirect_url),
('reserved', reserved),
]
encoded_params = urlencode(params)
url = '{base}?{params}#wechat_redirect'.format(base=base_url,
params=encoded_params)
return url
def get_jssdk_config(self, request, debug=None):
import time
from wechatpy.utils import random_string, to_text
from wechatpy.client.api import WeChatJSAPI
jsapi = WeChatJSAPI(self.get_wechat_client())
ticket = jsapi.get_jsapi_ticket()
nonce_str = random_string(32)
timestamp = to_text(int(time.time()))
url = request.META.get('HTTP_REFERER')
signature = jsapi.get_jsapi_signature(nonce_str, ticket, timestamp,
url)
debug = bool(request.GET.get('debug')) if debug is None else debug
return dict(
debug=debug,
appId=self.app_id,
timestamp=timestamp,
nonceStr=nonce_str,
signature=signature,
jsApiList=[
'checkJsApi', 'onMenuShareTimeline', 'onMenuShareAppMessage',
'onMenuShareQQ', 'onMenuShareWeibo', 'hideMenuItems',
'showMenuItems', 'hideAllNonBaseMenuItem',
'showAllNonBaseMenuItem', 'translateVoice', 'startRecord',
'stopRecord', 'onRecordEnd', 'playVoice', 'pauseVoice',
'stopVoice', 'uploadVoice', 'downloadVoice', 'chooseImage',
'previewImage', 'uploadImage', 'downloadImage',
'getNetworkType', 'openLocation', 'getLocation',
'hideOptionMenu', 'showOptionMenu', 'closeWindow',
'scanQRCode', 'chooseWXPay', 'openProductSpecificView',
'addCard', 'chooseCard', 'openCard'
],
)
def _request(self, method, url_or_endpoint, **kwargs):
if not url_or_endpoint.startswith(('http://', 'https://')):
api_base_url = kwargs.pop('api_base_url', self.API_BASE_URL)
url = '{base}{endpoint}'.format(base=api_base_url,
endpoint=url_or_endpoint)
else:
url = url_or_endpoint
if isinstance(kwargs.get('data', ''), dict):
data = optionaldict(kwargs['data'])
if 'mchid' not in data:
# F**k Tencent
data.setdefault('mch_id', self.mch_id)
data.setdefault('sub_mch_id', self.sub_mch_id)
data.setdefault('nonce_str', random_string(32))
sign = calculate_signature(data, self.api_key)
body = dict_to_xml(data, sign)
body = body.encode('utf-8')
kwargs['data'] = body
# 商户证书
if self.mch_cert and self.mch_key:
kwargs['cert'] = (self.mch_cert, self.mch_key)
res = requests.request(method=method, url=url, **kwargs)
try:
res.raise_for_status()
except requests.RequestException as reqe:
raise WeChatPayException(return_code=None,
client=self,
request=reqe.request,
response=reqe.response)
return self._handle_result(res)
def get_jsapi_params(self, prepay_id, timestamp=None, nonce_str=None, jssdk=False):
"""
获取 JSAPI 参数
:param prepay_id: 统一下单接口返回的 prepay_id 参数值
:param timestamp: 可选，时间戳，默认为当前时间戳
:param nonce_str: 可选，随机字符串，默认自动生成
:param jssdk: 前端调用方式，默认使用 WeixinJSBridge
使用 jssdk 调起支付的话，timestamp 的 s 为小写
使用 WeixinJSBridge 调起支付的话，timeStamp 的 S 为大写
:return: 参数
"""
data = {
'appId': self.sub_appid or self.appid,
'timeStamp': timestamp or to_text(int(time.time())),
'nonceStr': nonce_str or random_string(32),
'signType': 'MD5',
'package': 'prepay_id={0}'.format(prepay_id),
}
sign = calculate_signature(
data,
self._client.api_key if not self._client.sandbox else self._client.sandbox_api_key
)
logger.debug('JSAPI payment parameters: data = %s, sign = %s', data, sign)
data['paySign'] = sign
if jssdk:
data['timestamp'] = data.pop('timeStamp')
return data
def get_subscribe_authorize_url(self, scene, template_id, redirect_url, reserved=None):
"""
构造请求用户授权的url
详情请参阅：
https://mp.weixin.qq.com/wiki?id=mp1500374289_66bvB
:param scene: 订阅场景值，开发者可以填0-10000的整形值，用来标识订阅场景值
:type scene: int
:param template_id: 订阅消息模板ID，登录公众平台后台，在接口权限列表处可查看订阅模板ID
:param redirect_url: 授权后重定向的回调地址
:param reserved: 用于保持请求和回调的状态，授权请后原样带回给第三方。该参数可用于防止csrf攻击。若不指定则随机生成。
"""
if reserved is None:
reserved = random_string()
base_url = 'https://mp.weixin.qq.com/mp/subscribemsg'
params = [
('action', 'get_confirm'),
('appid', self.appid),
('scene', scene),
('template_id', template_id),
('redirect_url', redirect_url),
('reserved', reserved),
]
encoded_params = six.moves.urllib.parse.urlencode(params)
url = '{base}?{params}#wechat_redirect'.format(base=base_url, params=encoded_params)
return url
def get_jsapi_params(self, prepay_id, timestamp=None, nonce_str=None, jssdk=False):
"""
获取 JSAPI 参数
:param prepay_id: 统一下单接口返回的 prepay_id 参数值
:param timestamp: 可选，时间戳，默认为当前时间戳
:param nonce_str: 可选，随机字符串，默认自动生成
:param jssdk: 前端调用方式，默认使用 WeixinJSBridge
使用 jssdk 调起支付的话，timestamp 的 s 为小写
使用 WeixinJSBridge 调起支付的话，timeStamp 的 S 为大写
:return: 参数
"""
data = {
"appId": self.sub_appid or self.appid,
"timeStamp": timestamp or to_text(int(time.time())),
"nonceStr": nonce_str or random_string(32),
"signType": "MD5",
"package": f"prepay_id={prepay_id}",
}
sign = calculate_signature(
data, self._client.api_key if not self._client.sandbox else self._client.sandbox_api_key,
)
logger.debug("JSAPI payment parameters: data = %s, sign = %s", data, sign)
data["paySign"] = sign
if jssdk:
data["timestamp"] = data.pop("timeStamp")
return data
def _fetch_sandbox_api_key(self):
nonce_str = random_string(32)
sign = calculate_signature({"mch_id": self.mch_id, "nonce_str": nonce_str}, self.api_key)
payload = dict_to_xml({"mch_id": self.mch_id, "nonce_str": nonce_str,}, sign=sign)
headers = {"Content-Type": "text/xml"}
api_url = f"{self.API_BASE_URL}sandboxnew/pay/getsignkey"
response = self._http.post(api_url, data=payload, headers=headers)
return xmltodict.parse(response.text)["xml"].get("sandbox_signkey")
def get_jsapi_ticket(self, url):
us_client = self.wechatpy_client
jsapi = WeChatJSAPI(us_client)
tick = jsapi.get_jsapi_ticket()
noncestr = random_string()
timestamp = str(int(time.time()))
signature = jsapi.get_jsapi_signature(noncestr, tick, timestamp, url)
return self.wx_appid, timestamp, noncestr, signature
def upload_again(request):
print("开始重新上传")
user = request.session["user"]
if request.method == "POST":
punch_id = request.POST.get("punch_id")
base_64 = request.POST.get("base_64")
goal_id = request.POST.get('goal', ' ')
# mediaid = request.POST.get('serverId', ' ')
document = request.POST.get("document", " ")
distance = request.POST.get("distance", " ")
# apiLink = mediaApiClient.get_url(mediaid)
# response = requests.get(apiLink)
# user_wechat_id = user.wechat_id
# User 名字加随机字符串
fileName = user.wechat_id + "_" + "{}".format(
user.user_id) + "_" + random_string(16) + ".jpg"
# 文件存储的实际路径
filePath = os.path.join(settings.MEDIA_DIR,
timezone.now().strftime("%Y-%m-%d") + "/")
# 引用所使用的路径
refPath = os.path.join(settings.MEDIA_ROOT,
timezone.now().strftime("%Y-%m-%d") + "/")
bash_str = "".join(base_64).split(",")[1]
imgdata = base64.b64decode(bash_str)
file_filepath = filePath + fileName
print('原本的文件路径', file_filepath)
file_refpath = refPath + fileName
print("引用文件的路径", file_refpath)
# 写入文件内容
with open(filePath + fileName, 'wb') as f:
f.write(imgdata)
record = RunningPunchRecord.objects.get(punch_id=punch_id)
record.reload += 1
record.voucher_ref = file_refpath
record.document = document
record.voucher_store = file_filepath
record.record_time = timezone.now()
record.save()
print("重新上传成功")
goal = RunningGoal.objects.get(user_id=user.user_id)
# 自由模式剩余距离
left_distance = goal.left_distance
if goal.goal_type == 0:
# 重写之前还剩下的距离
killo = record.distance + left_distance
# 重写累计距离
goal.add_distance = float(goal.add_distance) - float(
record.distance) + float(distance)
goal.left_distance = float(killo) - float(distance)
goal.save()
record.distance = distance
record.save()
else:
print("success")
# record.save()
return JsonResponse({'status': 201})
else:
return HttpResponseNotFound
def get_jsapi_add_card_params(
self,
card_id: str,
code: str = "",
openid: str = "",
fixed_begintimestamp: int = 0,
outer_str: str = "",
nonce_str: str = "",
timestamp: int = 0,
card_ticket: str = "",
) -> JsapiCardExt:
"""
用于生成 jsapi 批量添加卡券接口的 cardList 参数中的 cardExt 参数
参数意义见微信文档地址：
https://developers.weixin.qq.com/doc/offiaccount/OA_Web_Apps/JS-SDK.html#65 和
https://developers.weixin.qq.com/doc/offiaccount/Cards_and_Offer/WeChat_Coupon_Interface.html#4
:param card_id: 卡券ID. 一个卡券ID对应一类卡券, 包含了相应库存数量的Code码.
:param code: 卡券Code码. 一张卡券的唯一标识, 核销卡券时使用此串码, 支持商户自定义.
:param openid: 用户在该公众号下的唯一身份.
:param fixed_begintimestamp: 卡券在第三方系统的实际领取时间, 为东八区时间戳 (UTC+8,精确到秒) . 当卡券的有效期类型为
DATE_TYPE_FIX_TERM 时专用, 标识卡券的实际生效时间,
用于解决商户系统内起始时间和领取时间不同步的问题.
:param outer_str: 领取渠道参数, 用于标识本次领取的渠道值. 支持商户自定义场景值填入card_ext进行卡券投放,
当用户领取时会将相应场景值通过事件通知商户.
:param nonce_str: 随机字符串, 由开发者设置传入, 加强安全性 (若不填写可能被重放请求).
:param timestamp: unix 时间戳, 不同添加请求的时间戳须动态生成, 若重复将会导致领取失败.
:param card_ticket: 用于卡券的微信 api_ticket
:return: 卡券的附加信息 card_ext 的 dict
"""
nonce_str = nonce_str or random_string()
timestamp = timestamp or int(time.time())
card_ticket = card_ticket or self.get_jsapi_card_ticket()
card_signature_dict = {
"nonce_str": nonce_str,
"api_ticket": card_ticket,
"timestamp": str(timestamp),
"code": code,
"openid": openid,
"card_id": card_id,
}
list_before_sign = sorted(
[str(x) for x in card_signature_dict.values()])
str_to_sign = "".join(list_before_sign).encode()
print(str_to_sign)
card_ext = JsapiCardExt(
code=code,
openid=openid,
timestamp=str(timestamp),
fixed_begintimestamp=fixed_begintimestamp,
outer_str=outer_str,
nonce_str=nonce_str,
signature=hashlib.sha1(str_to_sign).hexdigest(),
)
return card_ext
def get_jssdk_config(self, request, debug=None):
import time
from wechatpy.utils import random_string, to_text
from wechatpy.client.api import WeChatJSAPI
jsapi = WeChatJSAPI(self.get_wechat_client())
ticket = jsapi.get_jsapi_ticket()
nonce_str = random_string(32)
timestamp = to_text(int(time.time()))
url = request.META.get('HTTP_REFERER')
signature = jsapi.get_jsapi_signature(nonce_str, ticket, timestamp, url)
debug = bool(request.GET.get('debug')) if debug is None else debug
return dict(
debug=debug,
appId=self.app_id,
timestamp=timestamp,
nonceStr=nonce_str,
signature=signature,
jsApiList=[
'checkJsApi',
'onMenuShareTimeline',
'onMenuShareAppMessage',
'onMenuShareQQ',
'onMenuShareWeibo',
'hideMenuItems',
'showMenuItems',
'hideAllNonBaseMenuItem',
'showAllNonBaseMenuItem',
'translateVoice',
'startRecord',
'stopRecord',
'onRecordEnd',
'playVoice',
'pauseVoice',
'stopVoice',
'uploadVoice',
'downloadVoice',
'chooseImage',
'previewImage',
'uploadImage',
'downloadImage',
'getNetworkType',
'openLocation',
'getLocation',
'hideOptionMenu',
'showOptionMenu',
'closeWindow',
'scanQRCode',
'chooseWXPay',
'openProductSpecificView',
'addCard',
'chooseCard',
'openCard'
],
)
def get_jsapi_params(self, prepay_id):
""" 返回 jsapi 的付款对象 """
import time
from wechatpy.pay import api
from wechatpy.utils import random_string, to_text
jsapi = api.WeChatJSAPI(self.wechat_pay())
return jsapi.get_jsapi_params(
prepay_id=prepay_id,
nonce_str=random_string(32),
timestamp=to_text(int(time.time())),
)
def _fetch_sanbox_api_key(self):
nonce_str = random_string(32)
sign = calculate_signature({'mch_id': self.mch_id, 'nonce_str': nonce_str}, self.api_key)
payload = dict_to_xml({
'mch_id': self.mch_id,
'nonce_str': nonce_str,
}, sign=sign)
headers = {'Content-Type': 'text/xml'}
api_url = '{base}sandboxnew/pay/getsignkey'.format(base=self.API_BASE_URL)
response = self._http.post(api_url, data=payload, headers=headers)
return xmltodict.parse(response.text)['xml'].get('sandbox_signkey')
def get_jsapi_params(self, prepay_id):
""" 返回 jsapi 的付款对象 """
import time
from wechatpy.pay import api
from wechatpy.utils import random_string, to_text
jsapi = api.WeChatJSAPI(self.wechat_pay())
return jsapi.get_jsapi_params(
prepay_id=prepay_id,
nonce_str=random_string(32),
timestamp=to_text(int(time.time())),
)
def get_context_data(self, **kwargs):
ctx = super(IndexView, self).get_context_data(**kwargs)
timestamp = time.time()
nonce_str = random_string(32)
ticket = wechat_client.jsapi.get_jsapi_ticket()
ctx['appId'] = settings.WX_APPID
ctx['nonce_str'] = nonce_str
ctx['timestamp'] = timestamp
ctx['signature'] = wechat_client.jsapi.get_jsapi_signature(
nonce_str, ticket, timestamp, self.request.build_absolute_uri())
return ctx
def _request(self, method, url_or_endpoint, **kwargs):
if not url_or_endpoint.startswith(('http://', 'https://')):
api_base_url = kwargs.pop('api_base_url', self.API_BASE_URL)
if self.sandbox:
api_base_url = '{url}sandboxnew/'.format(url=api_base_url)
url = '{base}{endpoint}'.format(
base=api_base_url,
endpoint=url_or_endpoint
)
else:
url = url_or_endpoint
if isinstance(kwargs.get('data', ''), dict):
data = kwargs['data']
if 'mchid' not in data:
# F**k Tencent
data.setdefault('mch_id', self.mch_id)
data.setdefault('sub_mch_id', self.sub_mch_id)
data.setdefault('nonce_str', random_string(32))
data = optionaldict(data)
if data.get('sign_type', 'MD5') == 'HMAC-SHA256':
sign = calculate_signature_hmac(data, self.sandbox_api_key if self.sandbox else self.api_key)
else:
sign = calculate_signature(data, self.sandbox_api_key if self.sandbox else self.api_key)
body = dict_to_xml(data, sign)
body = body.encode('utf-8')
kwargs['data'] = body
# 商户证书
if self.mch_cert and self.mch_key:
kwargs['cert'] = (self.mch_cert, self.mch_key)
kwargs['timeout'] = kwargs.get('timeout', self.timeout)
logger.debug('Request to WeChat API: %s %s\n%s', method, url, kwargs)
res = self._http.request(
method=method,
url=url,
**kwargs
)
try:
res.raise_for_status()
except requests.RequestException as reqe:
raise WeChatPayException(
return_code=None,
client=self,
request=reqe.request,
response=reqe.response
)
return self._handle_result(res)
def _request(self, method, url_or_endpoint, **kwargs):
if not url_or_endpoint.startswith(('http://', 'https://')):
api_base_url = kwargs.pop('api_base_url', self.API_BASE_URL)
if self.sandbox:
api_base_url = '{url}sandboxnew/'.format(url=api_base_url)
url = '{base}{endpoint}'.format(
base=api_base_url,
endpoint=url_or_endpoint
)
else:
url = url_or_endpoint
if isinstance(kwargs.get('data', ''), dict):
data = kwargs['data']
if 'mchid' not in data:
# F**k Tencent
data.setdefault('mch_id', self.mch_id)
data.setdefault('sub_mch_id', self.sub_mch_id)
data.setdefault('nonce_str', random_string(32))
data = optionaldict(data)
if data.get('sign_type', 'MD5') == 'HMAC-SHA256':
sign = calculate_signature_hmac(data, self.sandbox_api_key if self.sandbox else self.api_key)
else:
sign = calculate_signature(data, self.sandbox_api_key if self.sandbox else self.api_key)
body = dict_to_xml(data, sign)
body = body.encode('utf-8')
kwargs['data'] = body
# 商户证书
if self.mch_cert and self.mch_key:
kwargs['cert'] = (self.mch_cert, self.mch_key)
kwargs['timeout'] = kwargs.get('timeout', self.timeout)
logger.debug('Request to WeChat API: %s %s\n%s', method, url, kwargs)
res = self._http.request(
method=method,
url=url,
**kwargs
)
try:
res.raise_for_status()
except requests.RequestException as reqe:
raise WeChatPayException(
return_code=None,
client=self,
request=reqe.request,
response=reqe.response
)
return self._handle_result(res)
def _request(self, method, url_or_endpoint, **kwargs):
http_client = AsyncHTTPClient()
if not url_or_endpoint.startswith(('http://', 'https://')):
api_base_url = kwargs.pop('api_base_url', self.API_BASE_URL)
url = '{base}{endpoint}'.format(
base=api_base_url,
endpoint=url_or_endpoint
)
else:
url = url_or_endpoint
headers = {}
params = kwargs.pop('params', {})
params = urlencode(dict((k, to_binary(v)) for k, v in params.items()))
url = '{0}?{1}'.format(url, params)
data = kwargs.get('data')
if isinstance(data, dict):
data = optionaldict(data)
if 'mchid' not in data:
# F**k Tencent
data.setdefault('mch_id', self.mch_id)
data.setdefault('sub_mch_id', self.sub_mch_id)
data.setdefault('nonce_str', random_string(32))
sign = calculate_signature(data, self.api_key)
body = dict_to_xml(data, sign)
body = body.encode('utf-8')
else:
body = data
req = HTTPRequest(
url=url,
method=method.upper(),
headers=headers,
body=body
)
res = yield http_client.fetch(req)
if res.error is not None:
raise WeChatClientException(
errcode=None,
errmsg=None,
client=self,
request=req,
response=res
)
result = self._handle_result(res)
raise Return(result)
def _request(self, method, url_or_endpoint, **kwargs):
if not url_or_endpoint.startswith(("http://", "https://")):
api_base_url = kwargs.pop("api_base_url", self.API_BASE_URL)
if self.sandbox:
api_base_url = "{url}sandboxnew/".format(url=api_base_url)
url = "{base}{endpoint}".format(base=api_base_url,
endpoint=url_or_endpoint)
else:
url = url_or_endpoint
if isinstance(kwargs.get("data", ""), dict):
data = kwargs["data"]
if "mchid" not in data:
# F**k Tencent
data.setdefault("mch_id", self.mch_id)
data.setdefault("sub_mch_id", self.sub_mch_id)
data.setdefault("nonce_str", random_string(32))
data = optionaldict(data)
if data.get("sign_type", "MD5") == "HMAC-SHA256":
sign = calculate_signature_hmac(
data,
self.sandbox_api_key if self.sandbox else self.api_key)
else:
sign = calculate_signature(
data,
self.sandbox_api_key if self.sandbox else self.api_key)
body = dict_to_xml(data, sign)
body = body.encode("utf-8")
kwargs["data"] = body
# 商户证书
if self.mch_cert and self.mch_key:
kwargs["cert"] = (self.mch_cert, self.mch_key)
kwargs["timeout"] = kwargs.get("timeout", self.timeout)
logger.debug("Request to WeChat API: %s %s\n%s", method, url, kwargs)
res = self._http.request(method=method, url=url, **kwargs)
try:
res.raise_for_status()
except requests.RequestException as reqe:
raise WeChatPayException(
return_code=None,
client=self,
request=reqe.request,
response=reqe.response,
)
return self._handle_result(res)
async def jssdk_config(request):
url = request.headers.get("referer")
ticket = client.jsapi.get_jsapi_ticket()
timestamp = int(time.time())
nonce_str = random_string()
signature = client.jsapi.get_jsapi_signature(nonce_str, ticket, timestamp,
url)
return json({
"appid": appid,
"timestamp": timestamp,
"noncestr": nonce_str,
"signature": signature,
"url": url
})
def get_context_data(self, **kwargs):
ctx = super(IndexView, self).get_context_data(**kwargs)
timestamp = time.time()
nonce_str = random_string(32)
ticket = wechat_client.jsapi.get_jsapi_ticket()
ctx['appId'] = settings.WX_APPID
ctx['nonce_str'] = nonce_str
ctx['timestamp'] = timestamp
ctx['signature'] = wechat_client.jsapi.get_jsapi_signature(
nonce_str, ticket, timestamp, self.request.build_absolute_uri())
ctx['EOS_ACCOUNT'] = EOS_ACCOUNT
ctx['eosram_profile'] = Profile.objects.filter(
owner_id=self.request.user.pk).first()
return ctx
def get_jsapi_signature(self, prepay_id, timestamp=None, nonce_str=None):
"""
获取 JSAPI 签名
:param prepay_id: 统一下单接口返回的 prepay_id 参数值
:param timestamp: 可选，时间戳，默认为当前时间戳
:param nonce_str: 可选，随机字符串，默认自动生成
:return: 签名
"""
data = {
'appId': self.appid,
'timeStamp': timestamp or to_text(int(time.time())),
'nonceStr': nonce_str or random_string(32),
'signType': 'MD5',
'package': 'prepay_id={0}'.format(prepay_id),
}
return calculate_signature(data, self._client.api_key)
def jsapi_signature(request):
noncestr = random_string()
timestamp = int(time.time())
url = request.POST['url']
client = WeChatClient(settings.WECHAT_APPID, settings.WECHAT_SECRET)
ticket_response = client.jsapi.get_ticket()
signature = client.jsapi.get_jsapi_signature(noncestr,
ticket_response['ticket'],
timestamp, url)
ret_dict = {
'noncestr': noncestr,
'timestamp': timestamp,
'url': url,
'signature': signature,
}
return JsonResponse(ret_dict)
def getJsApiSign(request):
"""
微信JSAPI支付
"""
client = wxClient()
ticket = client.jsapi.get_jsapi_ticket()
noncestr = random_string(15)
timestamp = int(time.time())
url = request.build_absolute_uri()
signature = client.jsapi.get_jsapi_signature(noncestr, ticket, timestamp, url)
sign_package = {
"appId": settings.WECHAT_APPID,
"nonceStr": noncestr,
"timestamp": timestamp,
"signature": signature
}
return sign_package
def get_jsapi_signature(self, prepay_id, timestamp=None, nonce_str=None):
"""
获取 JSAPI 签名
:param prepay_id: 统一下单接口返回的 prepay_id 参数值
:param timestamp: 可选，时间戳，默认为当前时间戳
:param nonce_str: 可选，随机字符串，默认自动生成
:return: 签名
"""
data = {
'appId': self.appid,
'timeStamp': timestamp or to_text(int(time.time())),
'nonceStr': nonce_str or random_string(32),
'signType': 'MD5',
'package': 'prepay_id={0}'.format(prepay_id),
}
return calculate_signature(data, self._client.api_key)
def get_jsapi_params(appid, secret, url, noncestr=None, timestamp=None):
"""获取调用 JS API 时需要的参数"""
client = WeChatClient(appid, secret)
jsapi_client = WeChatJSAPI(client=client)
timestamp = timestamp or to_text(int(time.time()))
noncestr = noncestr or random_string(32)
jsapi_ticket = jsapi_client.get_jsapi_ticket()
signature = jsapi_client.get_jsapi_signature(noncestr, jsapi_ticket,
timestamp, url)
params = {
'appId': appid,
'timestamp': timestamp,
'nonceStr': noncestr,
'signature': signature,
}
return params
def get_jsapi_signature(self, prepay_id, timestamp=None, nonce_str=None):
"""
获取 JSAPI 签名
:param prepay_id: 统一下单接口返回的 prepay_id 参数值
:param timestamp: 可选，时间戳，默认为当前时间戳
:param nonce_str: 可选，随机字符串，默认自动生成
:return: 签名
"""
data = {
"appId": self.sub_appid or self.appid,
"timeStamp": timestamp or to_text(int(time.time())),
"nonceStr": nonce_str or random_string(32),
"signType": "MD5",
"package": f"prepay_id={prepay_id}",
}
return calculate_signature(
data, self._client.api_key if not self._client.sandbox else self._client.sandbox_api_key,
)
def get_jsapi_card_params(self, card_ticket, card_type, **kwargs):
"""
参数意义见微信文档地址：http://mp.weixin.qq.com/wiki/7/aaa137b55fb2e0456bf8dd9148dd613f.html
:param card_ticket: 用于卡券的微信 api_ticket
:param card_type:
:param kwargs: 非必须参数：noncestr, timestamp, code, openid, fixed_begintimestamp, outer_str
:return: 包含调用jssdk所有所需参数的 dict
"""
card_signature_dict = {
'card_type': card_type,
'noncestr': kwargs.get('noncestr', random_string()),
'api_ticket': card_ticket,
'appid': self.appid,
'timestamp': kwargs.get('timestamp', str(int(time.time()))),
}
list_before_sign = sorted([str(x) for x in card_signature_dict.values()])
str_to_sign = "".join(list_before_sign).encode()
card_signature_dict['sign'] = hashlib.sha1(str_to_sign).hexdigest()
return card_signature_dict
def get_appapi_params(self, prepay_id, timestamp=None, nonce_str=None):
"""
获取 APP 支付参数
:param prepay_id: 统一下单接口返回的 prepay_id 参数值
:param timestamp: 可选，时间戳，默认为当前时间戳
:param nonce_str: 可选，随机字符串，默认自动生成
:return: 签名
"""
data = {
"appId": self.appid,
"package": "prepay_id={}".format(prepay_id),
"timeStamp": timestamp or to_text(int(time.time())),
"nonceStr": nonce_str or random_string(32),
"signType": "MD5",
}
sign = calculate_signature(data, self._client.api_key)
data["paySign"] = sign
return data
def get_jsapi_card_params(self, card_ticket, card_type, **kwargs):
"""
参数意义见微信文档地址：https://developers.weixin.qq.com/doc/offiaccount/OA_Web_Apps/JS-SDK.html#62
:param card_ticket: 用于卡券的微信 api_ticket
:param card_type:
:param kwargs: 非必须参数：noncestr, timestamp, code, openid, fixed_begintimestamp, outer_str
:return: 包含调用jssdk所有所需参数的 dict
"""
card_signature_dict = {
"card_type": card_type,
"noncestr": kwargs.get("noncestr", random_string()),
"api_ticket": card_ticket,
"appid": self.appid,
"timestamp": kwargs.get("timestamp", str(int(time.time()))),
}
list_before_sign = sorted([str(x) for x in card_signature_dict.values()])
str_to_sign = "".join(list_before_sign).encode()
card_signature_dict["sign"] = hashlib.sha1(str_to_sign).hexdigest()
return card_signature_dict
def get_jsapi_card_params(self, card_ticket, card_type, **kwargs):
"""
参数意义见微信文档地址：http://mp.weixin.qq.com/wiki/7/aaa137b55fb2e0456bf8dd9148dd613f.html
:param card_ticket: 用于卡券的微信 api_ticket
:param card_type:
:param kwargs: 非必须参数：noncestr, timestamp, code, openid, fixed_begintimestamp, outer_str
:return: 包含调用jssdk所有所需参数的 dict
"""
card_signature_dict = {
'card_type': card_type,
'noncestr': kwargs.get('noncestr', random_string()),
'api_ticket': card_ticket,
'appid': self.appid,
'timestamp': kwargs.get('timestamp', str(int(time.time()))),
}
list_before_sign = sorted([str(x) for x in card_signature_dict.values()])
str_to_sign = "".join(list_before_sign).encode()
card_signature_dict['sign'] = hashlib.sha1(str_to_sign).hexdigest()
return card_signature_dict
def get_appapi_params(self, prepay_id, timestamp=None, nonce_str=None):
"""
获取 APP 支付参数
:param prepay_id: 统一下单接口返回的 prepay_id 参数值
:param timestamp: 可选，时间戳，默认为当前时间戳
:param nonce_str: 可选，随机字符串，默认自动生成
:return: 签名
"""
data = {
'appId': self.appid,
'timeStamp': timestamp or to_text(int(time.time())),
'nonceStr': nonce_str or random_string(32),
'package': 'prepay_id=%s' % prepay_id,
'signType': 'MD5',
}
sign = calculate_signature(data, self._client.api_key)
data['paySign'] = sign
return data
def _request(self, method, url_or_endpoint, **kwargs):
if not url_or_endpoint.startswith(('http://', 'https://')):
api_base_url = kwargs.pop('api_base_url', self.API_BASE_URL)
url = '{base}{endpoint}'.format(
base=api_base_url,
endpoint=url_or_endpoint
)
else:
url = url_or_endpoint
if isinstance(kwargs.get('data', ''), dict):
data = optionaldict(kwargs['data'])
if 'mchid' not in data:
# F**k Tencent
data.setdefault('mch_id', self.mch_id)
data.setdefault('sub_mch_id', self.sub_mch_id)
data.setdefault('nonce_str', random_string(32))
sign = calculate_signature(data, self.api_key)
body = dict_to_xml(data, sign)
body = body.encode('utf-8')
kwargs['data'] = body
# 商户证书
if self.mch_cert and self.mch_key:
kwargs['cert'] = (self.mch_cert, self.mch_key)
res = requests.request(
method=method,
url=url,
**kwargs
)
try:
res.raise_for_status()
except requests.RequestException as reqe:
raise WeChatPayException(
return_code=None,
client=self,
request=reqe.request,
response=reqe.response
)
return self._handle_result(res)
def get_appapi_params(self, prepay_id, timestamp=None, nonce_str=None):
"""
获取 APP 支付参数
:param prepay_id: 统一下单接口返回的 prepay_id 参数值
:param timestamp: 可选，时间戳，默认为当前时间戳
:param nonce_str: 可选，随机字符串，默认自动生成
:return: 签名
"""
data = {
'appid': self.appid,
'partnerid': self.mch_id,
'prepayid': prepay_id,
'package': 'Sign=WXPay',
'timestamp': timestamp or to_text(int(time.time())),
'noncestr': nonce_str or random_string(32)
}
sign = calculate_signature(data, self._client.api_key)
data['sign'] = sign
return data
def get_random_string(self):
return random_string(16)
