def run(self):
print("红包订单同步开始!")
while True:
redisRes = self.redis_client.brpop(self.lKey)[1]
if not redisRes:
continue
self.ordercode = redisRes.decode('utf-8').split("|allwin|")[0]
self.session = redisRes.decode('utf-8').split("|allwin|")[1]
self.endtime = redisRes.decode('utf-8').split("|allwin|")[2]
if UtilTime().timestamp >= int(self.endtime):
continue
try:
orderObj = Order.objects.get(ordercode=self.ordercode)
wbPayClass = WeiboPay(sessionRes=json.loads(self.session))
payordercode = wbPayClass.getPayId(
json.loads(orderObj.jd_data)['payurl'])
orderObj.jd_payordercode = payordercode
orderObj.save()
weiboHandler = callback()
weiboHandler.redis_client.lpush(
weiboHandler.lKey,
"{}|allwin|{}|allwin|{}|allwin|{}".format(
orderObj.ordercode, orderObj.jd_payordercode,
self.session,
UtilTime().today.replace(minutes=120).timestamp))
except Exception as e:
self.redisdataCall(str(e))
continue
def get_date(obj):
if obj.get("type") == "appoint":
return obj.get("value")
else:
ut = UtilTime()
return ut.timestamp * 1000 \
if obj.get("format", None) == 'timestamp' else \
ut.arrow_to_string(arrow_s=ut.today, format_v=obj.get("format", None)) if obj.get("format", None) \
else ut.arrow_to_string(arrow_s=ut.today)
def order_valid_task():
"""
订单过期处理,每天凌晨3点处理昨天的过期情况
:return:
"""
with transaction.atomic():
ut = UtilTime()
# last_day_time = ut.string_to_timestamp(ut.arrow_to_string(ut.today.replace(days=-1), format_v="YYYY-MM-DD") + ' 00:00:01')
today_time = ut.string_to_timestamp(ut.arrow_to_string(ut.today,format_v="YYYY-MM-DD")+' 00:00:01')
Order.objects.filter(createtime__lte=today_time,status="1").update(status="3",down_status='3')
def __init__(self, type=None):
self.ut = UtilTime()
#当前时间
self.today = self.ut.today
#有效时间
self.order_failure_time = int(get_sysparam().order_failure_time)
#二维码类型
self.type = type
def get_today_bal(self, obj):
tot = 0
ut = UtilTime()
today = ut.arrow_to_string(ut.today, format_v="YYYY-MM-DD")
today_start = ut.string_to_timestamp(today + ' 00:00:01')
today_end = ut.string_to_timestamp(today + ' 23:59:59')
for item in Order.objects.filter(createtime__lte=today_end,
createtime__gte=today_start,
status="0"):
tot = float(tot) + float(item.myfee)
return round(tot, 2)
def get_today(self, obj):
tot = 0
ut = UtilTime()
today = ut.arrow_to_string(ut.today, format_v="YYYY-MM-DD")
today_start = ut.string_to_timestamp(today + ' 00:00:01')
today_end = ut.string_to_timestamp(today + ' 23:59:59')
for item in PayCallList.objects.filter(name=obj.name,
createtime__lte=today_end,
createtime__gte=today_start,
status="0"):
tot = float(tot) + float(item.amount)
return tot
def __init__(self,amount):
self.ut = UtilTime()
self.amount = amount
#当前时间
self.today = self.ut.today
#有效时间 300秒
self.order_failure_time = 300
#订单失效时间 4填
self.order_max_failure_time = 3 * 24 * 60 * 60
def order_count():
"""
订单统计
:return:
"""
ut = UtilTime()
lastday = ut.today.replace(days=-1)
startdate = ut.string_to_timestamp(ut.arrow_to_string(lastday,format_v="YYYY-MM-DD")+' 00:00:00')
enddate = ut.string_to_timestamp(ut.arrow_to_string(lastday,format_v="YYYY-MM-DD")+' 23:59:59')
with transaction.atomic():
print("订单统计，日期：{}...".format(ut.arrow_to_string(lastday,format_v="YYYY-MM-DD")))
for user in Users.objects.filter(rolecode='2001',status='0',createtime__lt=enddate):
orders = Order.objects.filter(userid=user.userid,createtime__gte=startdate,createtime__lte=enddate)
ordercount_insert=dict()
ordercount_insert["tot_order_count"] = orders.count()
ordercount_insert["today_success_order_count"] = 0
ordercount_insert["today_amount"] = 0.0
ordercount_insert["userid"] = user.userid
for order in orders:
if order.status=='0':
ordercount_insert["today_success_order_count"] += 1
ordercount_insert["today_amount"] += float(order.amount)
ordercount_insert["today_rate"] = ordercount_insert["today_success_order_count"] * 1.0 / ordercount_insert["tot_order_count"] \
if ordercount_insert["tot_order_count"] else 0.0
ordercount_insert["today"] = ut.arrow_to_string(lastday,format_v="YYYY-MM-DD")
OrderCount.objects.create(**ordercount_insert)
def filterOrder():
print("开始执行保留1个月订单操作!")
with transaction.atomic():
obj = Order.objects.filter(createtime__lt = UtilTime().today.replace(days=-15).timestamp)
if obj.exists():
for item in obj:
item.delete()
obj = BalList.objects.filter(createtime__lt = UtilTime().today.replace(days=-15).timestamp)
if obj.exists():
for item in obj:
item.delete()
print("执行结束")
def run(self):
print("红包回调处理开启!")
while True:
redisRes = self.redis_client.brpop(self.lKey)[1]
if not redisRes:
continue
self.ordercode = redisRes.decode('utf-8').split("|")[0]
self.other_ordercode = redisRes.decode('utf-8').split("|")[1]
self.session = redisRes.decode('utf-8').split("|")[2]
self.endtime = redisRes.decode('utf-8').split("|")[3]
if UtilTime().timestamp >= int(self.endtime):
continue
try:
ut = UtilTime()
start_time = ut.arrow_to_string(format_v="YYYY-MM-DD")
end_time = ut.arrow_to_string(ut.today.shift(days=-3),format_v="YYYY-MM-DD")
flag,s= WeiboCallBack(sessionRes=json.loads(self.session),cookieKey='pccookie',isSession=True)\
.queryOrderForWeibo(ordercode=self.ordercode,start_time=start_time,end_time=end_time)
if not flag:
self.redisdataCall("查询失败!{}".format(s))
continue
else:
if not len(s):
self.redisdataCall("查询无数据!{}".format(s))
continue
else:
if s[0]['status'] == '2':
pass
elif s[0]['status'] == '4':
self.redisdataCall("交易关闭!{}".format(s))
continue
elif s[0]['status'] == '1':
self.redisdataCall()
continue
else:
self.redisdataCall("未知状态!{}".format(s))
continue
request_data = {"orderid": self.ordercode}
result = request('POST', url=urllib.parse.unquote(
'{}/callback_api/lastpass/jingdong_callback'.format(url_join())), data=request_data,json=request_data, verify=False)
if result.text != 'success':
logger.info("请求对方服务器错误! {}".format(self.ordercode))
except Exception as e:
self.redisdataCall(str(e))
continue
def setWeiboUserinfo(self, request):
try:
Users.objects.get(google_token=request.data['token'].strip())
except Users.DoesNotExist:
raise PubErrorCustom("token不存在!")
if not request.data.get("datas"):
raise PubErrorCustom("无会话数据!")
for item in request.data.get("datas"):
try:
s = WeiboUser.objects.get(id=item['id'])
except WeiboUser.DoesNotExist:
raise PubErrorCustom("无此账户信息!{}".format(item['id']))
if not len(s.session):
s.session = {}
s.uid = item['uid']
s.session_status = '0'
s.session['uid'] = item['uid']
s.session['cookie'] = {}
s.session['cookie']['pccookie'] = item['session']
else:
s.session = json.loads(s.session)
if not len(s.session['cookie']):
s.session['cookie'] = {}
s.session['cookie']['pccookie'] = item['session']
s.session_status = '0'
s.logintime = UtilTime().timestamp
s.session = json.dumps(s.session)
s.save()
return None
def __init__(self, **kwargs):
# 是否充值
self.isPay = kwargs.get('isPay', False)
# 是否提现
self.isCashout = kwargs.get('isCashout', False)
# 是否提现拒绝
self.isCashoutCanle = kwargs.get('isCashoutCanle', False)
# 是否提现确认
self.isCashoutConfirm = kwargs.get('isCashoutConfirm', False)
# 是否冻结
self.isStop = kwargs.get('isStop', False)
# 是否解冻
self.isStopCanle = kwargs.get('isStopCanle', False)
userid = kwargs.get('userid', None)
if not userid:
raise PubErrorCustom("用户代码不能为空!")
self.amount = kwargs.get('amount', None)
if not self.amount:
raise PubErrorCustom("交易金额不能为空!")
else:
self.amount = float(self.amount)
self.ordercode = kwargs.get('ordercode', 0)
try:
self.user = Users.objects.select_for_update().get(userid=userid)
except Users.DoesNotExist:
raise PubErrorCustom("无对应用户信息({})".format(userid))
logger.info(
"""动账前: userid:{} upd_bal_date:{} amount:{} ordercode:{} bal:{} cashout_bal:{} stop_bal:{} lastday_bal:{} today_bal:{} lastday_pay_amount:{}
today_pay_amount:{} tot_pay_amount:{} lastday_cashout_amount:{} today_cashout_amount:{} tot_cashout_amount:{}"""
.format(
self.user.userid,
self.user.upd_bal_date,
self.amount,
self.ordercode,
self.user.bal,
self.user.cashout_bal,
self.user.stop_bal,
self.user.lastday_bal,
self.user.today_bal,
self.user.lastday_pay_amount,
self.user.today_pay_amount,
self.user.tot_pay_amount,
self.user.lastday_cashout_amount,
self.user.today_cashout_amount,
self.user.tot_cashout_amount,
))
self.today = UtilTime().arrow_to_string(format_v="YYYYMMDD")
self.RunUpdDate()
def setWeiboUserinfo(self,request):
print(request.data)
if not request.data.get("datas"):
raise PubErrorCustom("无会话数据!")
for item in request.data.get("datas"):
try:
s = WeiboPayUsername.objects.get(id=item['id'])
except WeiboPayUsername.DoesNotExist:
raise PubErrorCustom("无此账户信息!{}".format(item['id']))
if not len(s.session):
s.session = {}
s.session['uid'] = item['uid']
s.session['cookie']={}
s.session['cookie']['pccookie'] = item['session']
else:
s.session = json.loads(s.session)
if not len(s.session['cookie']):
s.session['cookie']={}
s.session['cookie']['pccookie'] = item['session']
s.logintime = UtilTime().timestamp
s.session = json.dumps(s.session)
s.save()
return None
def __init__(self, **kwargs):
self.amount = kwargs.get('amount', None)
if not self.amount:
raise PubErrorCustom("交易金额不能为空!")
else:
self.amount = float(self.amount)
self.ordercode = kwargs.get('ordercode', 0)
self.memo = kwargs.get("memo", "")
userid = kwargs.get('userid', None)
user = kwargs.get('user', None)
if not (userid or user):
raise PubErrorCustom("用户代码不能为空!")
if not user:
try:
self.user = Users.objects.select_for_update().get(
userid=userid)
except Users.DoesNotExist:
raise PubErrorCustom("无对应用户信息({})".format(userid))
else:
self.user = user
paypassid = kwargs.get("paypassid", None)
userbal = kwargs.get('userbal', None)
if not (paypassid or userbal):
raise PubErrorCustom("渠道ID不能为空!")
if not userbal:
try:
self.userBal = UserBal.objects.select_for_update().get(
userid=userid, paypassid=paypassid)
except UserBal.DoesNotExist:
self.userBal = UserBal.objects.create(**{
"userid": userid,
"paypassid": paypassid,
})
else:
self.userBal = userbal
logger.info(
"""动账前: userid:{} amount:{} ordercode:{} totbal:{} bal:{} cashout_bal:{} stop_bal:{}"""
.format(
self.user.userid,
self.user.upd_bal_date,
self.amount,
self.ordercode,
self.user.bal,
self.userBal.bal,
self.userBal.cashout_bal,
))
self.today = UtilTime().arrow_to_string(format_v="YYYYMMDD")
self.RunUpdDate()
def __init__(self, **kwargs):
#必查询字段
self.must_params = list(set([] + kwargs.get('must_params', [])))
#查询时过滤字段
self.filter_params = list(
set(['google_token', 'passwd', 'pay_passwd'] +
kwargs.get('filter_params', [])))
#带条件查询字段
self.condition_params = list(
set([] + kwargs.get('condition_params', [])))
#请求的值
self.filter_value = kwargs.get('filter_value') if kwargs.get(
'filter_value') else {}
#唯一key
self.must_key = kwargs.get('must_key') if kwargs.get(
'must_key') else ""
#唯一key value
self.must_key_value = kwargs.get('must_key_value') if kwargs.get(
'must_key_value') else ""
#方法
if not kwargs.get("method"):
raise PubErrorCustom("方法不能为空")
self.method = kwargs.get("method")
#表
if not kwargs.get("table"):
raise PubErrorCustom("表不能为空")
self.table = kwargs.get("table")
#序列化
self.serialiers = kwargs.get("serialiers")
self.ut = UtilTime()
kwargs.setdefault('key', self.table)
super().__init__(**kwargs)
def BalQuery(self):
self.data.setdefault("nonceStr", str(UtilTime().timestamp))
md5params = "{}{}{}{}".format(self.secret,
str(self.data.get("businessid")),
self.data.get("nonceStr"), self.secret)
md5params = md5params.encode("utf-8")
self.data.setdefault("sign", hashlib.md5(md5params).hexdigest())
return self._request("http://allwin6666.com/api_new/business/BalQuery")
def handler(self):
ok_bal = self.get_ok_bal()
if float(ok_bal) - abs(float(self.user.cashout_bal)) - float(
self.user.fee_rule) < float(self.data.get("amount")):
raise PubErrorCustom("可提余额不足!")
request = dict()
request["paypassid"] = self.paypasslinktype.passid
request["amount"] = float(self.data.get("amount"))
request["bank_name"] = hexStringTobytes(
self.data.get("bankName")).decode('utf-8')
request["open_name"] = hexStringTobytes(
self.data.get("accountName")).decode('utf-8')
request["bank_card_number"] = self.data.get("accountNo")
request["downordercode"] = self.data.get('down_ordercode')
request["memo"] = self.data.get("memo")
#单笔不允许超过50000
if request["amount"] - 50000.0 > 0.0:
raise PubErrorCustom("单笔下发不能超过50000,当前金额{}".format(
request["amount"]))
#3次内同一用户同一账户金额不能相同
res = CashoutList.objects.filter(
userid=self.user.userid,
bank_card_number=request["bank_card_number"],
df_status='1').order_by("-createtime")
if res.count() > 3:
res = res[:3]
for item in res:
if request["amount"] == float(item.amount):
raise PubErrorCustom("3次内同一银行卡下发金额不能相同！")
cashout_id = daifuBalTixian(request, self.user)
ordercode = "DF%08d%s" % (self.user.userid, request["downordercode"])
AccountCashoutConfirmForApiFee(user=self.user,
ordercode=ordercode).run()
AccountCashoutConfirmForApi(user=self.user,
amount=request["amount"],
ordercode=ordercode).run()
# float(self.user.fee_rule)
daifu = daifuCallBack()
daifu.redis_client.lpush(
daifu.lKey, "{}|{}|{}|{}|{}|{}".format(
self.user.userid, request["amount"], request["downordercode"],
request["paypassid"], cashout_id,
UtilTime().today.replace(minutes=120).timestamp))
return None
def df(self):
self.data.setdefault("nonceStr", str(UtilTime().timestamp))
self.data.setdefault('down_ordercode', str(UtilTime().timestamp))
self.data.setdefault('amount', 1.0)
# self.data.setdefault('accountNo','6226621704181682')
self.data.setdefault('memo', 'test')
self.data.setdefault('accountNo', '111')
self.data.setdefault('bankName', '中国光大银行'.encode('utf-8').hex())
self.data.setdefault('accountName', '陈丽红'.encode('utf-8').hex())
md5params = "{}{}{}{}{}{}{}{}{}{}".format(
self.secret, str(self.data.get("down_ordercode")),
str(self.data.get("businessid")), self.secret,
self.data.get("nonceStr"), str(self.data.get("amount")),
str(self.data.get("accountNo")), str(self.data.get("bankName")),
str(self.data.get("accountName")), self.secret)
md5params = md5params.encode("utf-8")
self.data.setdefault("sign", hashlib.md5(md5params).hexdigest())
return self._request("http://allwin6666.com/api_new/business/df")
def pass_count(self,request):
query_format = str()
query_params = list()
ut = UtilTime()
if request.query_params_format.get("today"):
today = request.query_params_format.get("today")
startdate = ut.string_to_timestamp(today+' 00:00:01',format_v="YYYY-MM-DD")
enddate = ut.string_to_timestamp(today+' 23:59:59',format_v="YYYY-MM-DD")
else:
today = ut.arrow_to_string(format_v="YYYY-MM-DD")
startdate = ut.string_to_timestamp(today+' 00:00:01')
enddate = ut.string_to_timestamp(today+' 23:59:59')
query_format = query_format + " and t1.createtime>=%s and t1.createtime<=%s"
query_params.append(startdate)
query_params.append(enddate)
if request.query_params_format.get("paypassid"):
query_format = query_format + " and t2.paypassid =%s"
query_params.append(request.query_params_format.get("paypassid"))
orders = Order.objects.raw("""
SELECT t1.* FROM `order` as t1
INNER JOIN `paypass` as t2 ON t1.paypass = t2.paypassid and t2.status='0'
WHERE 1=1 %s
"""% (query_format), query_params)
pass_order_dict={}
for order in orders :
if order.paypass not in pass_order_dict:
pass_order_dict[order.paypass]={
"id": order.paypass,
"name" : order.paypassname,
"amount" : 0.0,
"order_count":0,
"order_success_count":0,
"rate" : 0.0,
"today" : today[:10]
}
pass_order_dict[order.paypass]['order_count'] += 1
if order.status == '0':
pass_order_dict[order.paypass]['amount'] += float(order.amount)
pass_order_dict[order.paypass]['order_success_count'] += 1
data = []
for key in pass_order_dict:
pass_order_dict[key]['rate'] = "{}%".format(round(pass_order_dict[key]['order_success_count'] * 100.0 / pass_order_dict[key]['order_count'] \
if pass_order_dict[key]['order_count'] else 0.0 ,2))
data.append(pass_order_dict[key])
return {"data": data}
def dfQuery(self):
self.data.setdefault("nonceStr", str(UtilTime().timestamp))
self.data.setdefault('down_ordercode', '20537015002737810915')
md5params = "{}{}{}{}{}".format(self.secret,
str(self.data.get("down_ordercode")),
str(self.data.get("businessid")),
self.data.get("nonceStr"), self.secret)
md5params = md5params.encode("utf-8")
self.data.setdefault("sign", hashlib.md5(md5params).hexdigest())
return self._request("http://allwin6666.com/api_new/business/dfQuery")
def payafter(self,order,session):
from apps.weibohongbao.weiboCallback import callback
"""
微博订单回调通知
:param ordercode:系统订单号
:return:
"""
weiboHandler = callback()
weiboHandler.redis_client.lpush(weiboHandler.lKey, "{}|allwin|{}|allwin|{}|allwin|{}".format(
order.ordercode,
order.jd_payordercode,
session,
UtilTime().today.replace(minutes=120).timestamp))
def run(self):
self.data.setdefault('client_id', self.businessId)
self.data.setdefault('timestamp', UtilTime().timestamp * 1000)
self._sign()
try:
self._request()
return (
False,
self.response['msg']) if self.response['code'] != 200 else (
True, self.response['data'])
except Exception as e:
return (False, str(e))
def __init__(self,isQueryTask=True):
self.ut = UtilTime()
self.wbOUser = None
self.wbOTask = None
if isQueryTask:
wbOTasks = WeiboTask.objects.filter(umark='0',status='1',date=self.ut.arrow_to_string(format_v="YYYY-MM-DD")).order_by('sort')
if not wbOTasks.exists():
logger.error("无任务可执行!")
return
self.wbOTask = wbOTasks[0]
try:
self.wbOUser = WeiboUser.objects.get(uid=self.wbOTask.uid,status='0')
except WeiboUser.DoesNotExist:
logger.error("无可用组长!")
return
self.robnumber = self.wbOTask.robnumber
self.minamount = self.wbOTask.minamount
self.maxamount = self.wbOTask.maxamount
class jdHandler(object):
def __init__(self, data):
self.data = data
self.ut = UtilTime()
def OrderQuery(self):
if not self.data.get('day'):
raise PubErrorCustom("查询日期不能为空")
if len(self.data.get('day')) != 10:
raise PubErrorCustom("日期格式不正确")
start_day = self.data.get('day') + ' 00:00:01'
end_day = self.data.get('day') + ' 23:59:59'
start_day = self.ut.string_to_timestamp(string_s=start_day)
end_day = self.ut.string_to_timestamp(string_s=end_day)
return {
"data":
OrderModelSerializerToJd(Order.objects.filter(
isjd='0', createtime__lte=end_day, createtime__gte=start_day),
many=True).data
}
def __init__(self, **kwargs):
self.amount = kwargs.get('amount', None)
if not self.amount:
raise PubErrorCustom("交易金额不能为空!")
else:
self.amount = float(self.amount)
self.ordercode = kwargs.get('ordercode', 0)
userid = kwargs.get('userid', None)
user = kwargs.get('user', None)
if not (userid or user):
raise PubErrorCustom("用户代码不能为空!")
if not user:
try:
self.user = Users.objects.select_for_update().get(
userid=userid)
except Users.DoesNotExist:
raise PubErrorCustom("无对应用户信息({})".format(userid))
else:
self.user = user
logger.info(
"""动账前: userid:{} upd_bal_date:{} amount:{} ordercode:{} bal:{} cashout_bal:{} stop_bal:{} lastday_bal:{} today_bal:{} lastday_pay_amount:{}
today_pay_amount:{} tot_pay_amount:{} lastday_cashout_amount:{} today_cashout_amount:{} tot_cashout_amount:{}"""
.format(
self.user.userid,
self.user.upd_bal_date,
self.amount,
self.ordercode,
self.user.bal,
self.user.cashout_bal,
self.user.stop_bal,
self.user.lastday_bal,
self.user.today_bal,
self.user.lastday_pay_amount,
self.user.today_pay_amount,
self.user.tot_pay_amount,
self.user.lastday_cashout_amount,
self.user.today_cashout_amount,
self.user.tot_cashout_amount,
))
self.today = UtilTime().arrow_to_string(format_v="YYYYMMDD")
self.RunUpdDate()
def run(self):
self.data.setdefault('businessId', int(self.businessId))
self.data.setdefault('signType', 'MD5')
self.data.setdefault('payTitle', '商品1')
self.data.setdefault('random', UtilTime().timestamp)
self.data.setdefault('payMethod', 0)
self.data.setdefault('dataType', 0)
# self.data.setdefault('returnUrl',url_join("/pay/#/juli"))
self._sign()
try:
self._request()
return (False, self.response['errorDesc']
) if not self.response['successed'] else (
True, self.response['returnValue'])
except Exception as e:
return (False, str(e))
def phonelogin(self,username,vercode):
"""
:param username: 登录手机号
:param vercode: 验证码
:return:
"""
try:
wbUserObj = WeiboUser.objects.get(username=username)
except WeiboUser.DoesNotExist:
raise PubErrorCustom("账号不存在!")
wbLoginClass = WeiBoLoginForPhone()
wbUserObj.session = wbLoginClass.login_by_vercode(username,vercode)
wbUserObj.uid = wbUserObj.session['uid']
wbUserObj.session = json.dumps(wbUserObj.session)
wbUserObj.logintime = UtilTime().timestamp
wbUserObj.session_status = '0'
wbUserObj.save()
def get_ok_bal(self):
if self.paypasslinktype.passid in ['51', '54']:
weeknum = UtilTime().get_week_day()
if weeknum in [6, 7]:
ok_bal = float(self.user.today_pay_amount) * self.t0Tx - (
float(self.user.today_cashout_amount) +
float(self.user.today_fee_amount))
else:
ok_bal = float(self.user.lastday_bal) + (
float(self.user.today_pay_amount) * self.t0Tx -
(float(self.user.today_cashout_amount) +
float(self.user.today_fee_amount)))
print("用户ID{} 周几{} 昨日余额{} 当填充值金额{} 当天提现金额{} 当天手续费{}".format(
self.user.userid, weeknum, self.user.lastday_bal,
self.user.today_pay_amount, self.user.today_cashout_amount,
self.user.today_fee_amount))
else:
ok_bal = self.user.bal
return ok_bal
def get_token(self):
t = UtilTime().timestamp
data = dict(merchantNo=self.businessId,
key=self.secret,
nonce=str(t),
timestamp=t)
s = "merchantNo={}&nonce={}×tamp={}&key={}".format(
data['merchantNo'],
data['nonce'],
str(data['timestamp']),
data['key'],
)
print(s)
data['sign'] = md5pass(s).upper()
print(data)
result = request(
method='POST',
url="http://api.jinxiangweb.cn:8888/api/v1/getAccessToken/merchant",
data=data,
verify=False)
print(result.text)
response = json.loads(result.content.decode('utf-8'))
if response['success']:
self.token = response['value']['accessToken']
def callback_request_to_server(self):
"""
进行回调操作
:return:
"""
try:
user = Users.objects.get(userid=self.order_obj.userid)
except Users.DoesNotExist:
logger.error("订单用户不存在! 用户:{}".format(self.order_obj.userid))
raise PubErrorCustom("订单用户不存在!")
if self.order_obj.lock == '0':
data_request = {
"rescode": "10000",
"msg": "回调成功!",
"data": {
"ordercode": self.order_obj.ordercode,
"status": '0',
"confirm_amount": float(self.amount),
"pay_time": time.mktime(timezone.now().timetuple()),
"keep_info": demjson.decode(self.order_obj.keep_info)
},
"ordercode":str(self.order_obj.down_ordercode)
}
headers={
"token" : str(self.order_obj.userid),
"ordercode": str(self.order_obj.down_ordercode)
}
#天宝报文不加密
if user.userid != 4:
data_request['data'] = encrypt(json.dumps(data_request['data'], cls=DjangoJSONEncoder),
user.google_token).decode('utf-8')
result = send_request(url=urllib.parse.unquote(self.order_obj.notifyurl), method='POST', data=data_request,headers=headers)
if not result[0]:
logger.error("请求对方服务器错误{}".format(str(result)))
self.order_obj.down_status = '2'
else:
self.order_obj.down_status = '0'
else:
request_data = {
"businessid" : str(user.userid),
"ordercode" : str(self.order_obj.ordercode),
"down_ordercode" : str(self.order_obj.down_ordercode),
# "amount1": str(self.order_obj.amount),
"amount" : str(self.amount),
"pay_time" : str(UtilTime().timestamp),
"status" : "00"
}
md5params = "{}{}{}{}{}{}{}".format(
user.google_token,
request_data['businessid'],
request_data['ordercode'],
request_data['down_ordercode'],
request_data['amount'],
request_data['pay_time'],
user.google_token)
md5params = md5params.encode("utf-8")
request_data['sign'] = hashlib.md5(md5params).hexdigest()
logger.info("验签回调参数:{}{}".format(self.order_obj.notifyurl,request_data))
try:
result = request('POST', url=urllib.parse.unquote(self.order_obj.notifyurl), data=request_data , json=request_data, verify=False)
logger.info("返回值:{}".format(result.text))
if result.text.strip() != 'SUCCESS':
logger.error("请求对方服务器错误{}".format(str(result.text)))
self.order_obj.down_status = '2'
else:
self.order_obj.down_status = '0'
except Exception as e:
logger.info("下游错误:{}".format(str(e)))
self.order_obj.down_status = '2'
