def daifuOrderQuery(request):
obj = CashoutList.objects.filter(userid=request.get("userid"),
downordercode=request.get("dfordercode"))
if not obj.exists():
raise PubErrorCustom("此订单不存在!")
obj = obj[0]
dfordercode = "DF%08d%s" % (int(
request.get("userid")), str(request.get("dfordercode")))
if str(request.get('paypassid')) == '54':
res = LastPass_BAWANGKUAIJIE(data={"orderId": dfordercode}).df_query()
obj.textstatus = res
obj.save()
return {"data": {"msg": res}}
elif str(request.get('paypassid')) == '51':
res = LastPass_KUAIJIE(data={
"tradeCustorder": dfordercode
}).df_order_query()
obj.textstatus = res
obj.save()
return {"data": {"msg": res}}
elif str(request.get('paypassid')) == '69':
res = LastPass_GCPAYS().df_order_query(data={"orderNo": dfordercode})
# obj.textstatus = res[1]
# obj.save()
return {"data": {"code": res[0], "msg": res[1]}}
else:
raise PubErrorCustom("代付渠道有误!")
def callback(self,data):
iData = dict()
for item in data:
iData[item] = data[item]
logger.info("支付宝回调数据=>{}".format(iData))
sign = iData.pop("sign",None)
if not self.alipay.verify(iData,sign):
raise PubErrorCustom("验签失败!")
if iData.get("trade_status",None) != 'TRADE_SUCCESS':
raise PubErrorCustom("交易状态异常!")
#
# try:
# orderObj = Order.objects.select_for_update().get(orderid=iData.get("out_trade_no",""))
# if orderObj.status == '1':
# logger.info("订单{}已处理".format(orderObj.orderid))
# raise PubErrorCustom("订单{}已处理".format(orderObj.orderid))
# except Order.DoesNotExist:
# raise PubErrorCustom("订单不存在!")
#
# orderObj.status = '1'
# orderObj.save()
#
# user = Users.objects.select_for_update().get(userid=orderObj.userid)
#
# logger.info("用户{}积分余额{}使用积分{}获得积分{}".format(user.mobile,user.jf,orderObj.use_jf,orderObj.get_jf))
# user.jf -= orderObj.use_jf
# user.jf += orderObj.get_jf
# user.save()
#
logger.info("支付宝回调订单处理成功!=>{}".format(iData))
def Query(self):
if not self.data.get("businessid"):
raise PubErrorCustom("商户ID为空!")
if not self.data.get("down_ordercode"):
raise PubErrorCustom("商户订单号为空!")
if not self.data.get("nonceStr"):
raise PubErrorCustom("随机数!")
md5params = "{}{}{}{}{}".format(self.user.google_token,
str(self.data.get("down_ordercode")),
str(self.data.get("businessid")),
self.data.get("nonceStr"),
self.user.google_token)
md5params = md5params.encode("utf-8")
logger.info("代付查询待签数据:{}".format(md5params))
sign = hashlib.md5(md5params).hexdigest()
logger.info("代付查询签名:{}-----{}".format(sign, self.data.get("sign")))
if sign != self.data.get("sign"):
raise PubErrorCustom("验签失败!")
request = {}
# request['dfordercode'] = "DF%08d%s" % (self.user.userid,self.data.get("down_ordercode"))
request['dfordercode'] = self.data.get("down_ordercode")
request['userid'] = self.user.userid
request["paypassid"] = self.paypasslinktype.passid
return daifuOrderQuery(request)
def check_params(self):
if not self.data.get("businessid"):
raise PubErrorCustom("商户ID为空!")
if not self.data.get("down_ordercode"):
raise PubErrorCustom("商户订单号为空!")
if not self.data.get("nonceStr"):
raise PubErrorCustom("随机数!")
if not self.data.get("amount"):
raise PubErrorCustom("金额不能为空!")
if float(self.data.get("amount")) <= 0:
raise PubErrorCustom("请输入正确的提现金额!")
if not self.data.get("accountNo"):
raise PubErrorCustom("银行卡号不能为空!")
if not self.data.get("bankName"):
raise PubErrorCustom("银行名称不能为空!")
if not self.data.get("accountName"):
raise PubErrorCustom("账户名称不能为空!")
if not self.data.get("sign"):
raise PubErrorCustom("签名不能为空!")
md5params = "{}{}{}{}{}{}{}{}{}{}".format(
self.user.google_token, str(self.data.get("down_ordercode")),
str(self.data.get("businessid")), self.user.google_token,
str(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.user.google_token)
md5params = md5params.encode("utf-8")
logger.info("代付待签数据:{}".format(md5params))
sign = hashlib.md5(md5params).hexdigest()
logger.info("代付签名:{}-----{}".format(sign, self.data.get("sign")))
if sign != self.data.get("sign"):
raise PubErrorCustom("验签失败!")
def BalQuery(self):
if not self.data.get("businessid"):
raise PubErrorCustom("商户ID为空!")
if not self.data.get("nonceStr"):
raise PubErrorCustom("随机数!")
md5params = "{}{}{}{}".format(self.user.google_token,
str(self.data.get("businessid")),
self.data.get("nonceStr"),
self.user.google_token)
md5params = md5params.encode("utf-8")
logger.info("代付查询待签数据:{}".format(md5params))
sign = hashlib.md5(md5params).hexdigest()
logger.info("代付查询签名:{}-----{}".format(sign, self.data.get("sign")))
if sign != self.data.get("sign"):
raise PubErrorCustom("验签失败!")
# user = AccountBase(userid=self.user.userid,amount=1).query()
ok_bal = self.get_ok_bal()
return {
"data": {
"bal": round(float(self.user.bal), 2),
"stop_bal": round(float(self.user.stop_bal), 2),
"ok_bal": round(ok_bal, 2)
}
}
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 DF_chongzheng(self,request):
redisRes=request.data.get("row")
userid = redisRes.split("|")[0]
amount = redisRes.split("|")[1]
ordercode = redisRes.split("|")[2]
cashout_id = redisRes.split("|")[4]
try:
obj = CashoutList.objects.get(id=cashout_id)
obj.df_status = '2'
obj.save()
except CashoutList.DoesNotExist:
raise PubErrorCustom("无此提现明细!{}".format(cashout_id))
ordercodetmp = "DF%08d%s" % (int(userid), str(ordercode))
try:
user = Users.objects.select_for_update().get(userid=userid)
except Users.DoesNotExist:
raise PubErrorCustom("无此用户信息")
AccounRollBackForApiFee(user=user,ordercode=ordercodetmp).run()
AccountRollBackForApi(user=user, amount=float(amount),ordercode=ordercodetmp).run()
return None
def addTask(self, request, *args, **kwargs):
try:
wbGObj = WeiboGroup.objects.get(group_id=request.data_format['group'])
except WeiboGroup.DoesNotExist:
raise PubErrorCustom("群不存在!")
robnumber = WeiboGroupMember.objects.filter(group_id=wbGObj.group_id).count()
if robnumber<=0:
raise PubErrorCustom("群里无人员！")
if 100%robnumber>0:
raise PubErrorCustom("群抢红包人数必须被100整除!")
WeiboTask.objects.create(**dict(
userid = request.user.userid,
taskname = request.data_format['name'],
minamount = request.data_format['minamount'],
maxamount = request.data_format['maxamount'],
groupid = wbGObj.group_id,
amountwhat = request.data_format['amountwhat'],
uid = wbGObj.uid,
sort = request.data_format['sort'],
date = request.data_format['date'],
robnumber = robnumber
))
return None
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 requestHandlerForJson(self):
"""
"request":{
"url":"http://localhost:8000",
"method" : "POST",
"type":"json",
},
"""
logger.info("向上游请求的值：{}".format(json.dumps(self.request_data)))
try:
if self.rules.get("request").get("type") == 'json':
result = request(
url=self.rules.get("request").get("url"),
method=self.rules.get("request").get("method"),
json=self.request_data,
headers={"Content-Type": 'application/json'},
verify=False,
timeout=5)
elif self.rules.get("request").get("type") == 'body':
result = request(
url=self.rules.get("request").get("url"),
method=self.rules.get("request").get("method"),
data=self.request_data,
verify=False,
timeout=5)
elif self.rules.get("request").get("type") == 'params':
if self.passid == 76:
url = self.rules.get("request").get(
"url") + "?params={}".format(
json.dumps(self.request_data))
# data['params'] = self.request_data
print(url)
result = request(
url=url,
method=self.rules.get("request").get("method"),
verify=False,
timeout=5)
else:
result = request(
url=self.rules.get("request").get("url"),
method=self.rules.get("request").get("method"),
params=self.request_data,
verify=False,
timeout=5)
else:
raise PubErrorCustom("请求参数错误!")
except Exception as e:
logger.error(str(e))
raise PubErrorCustom(
"上游系统很慢，超时了，麻烦别找我，发给上游，谢谢!!!!!!!(慢到什么程度 5秒没有反应，5秒是什么概念，基本上系统已经瘫痪了！！！！！)"
)
try:
self.response = json.loads(result.content.decode('utf-8'))
logger.info("上游返回值：{}".format(result.content.decode('utf-8')))
except Exception as e:
raise PubErrorCustom("返回JSON错误!{}".format(result.text))
def pcPreLogin(self, request, *args, **kwargs):
try:
wbUobj = WeiboUser.objects.get(id=request.data['id'])
except WeiboUser.DoesNotExist:
raise PubErrorCustom("无此账号信息!")
if wbUobj.type != '0':
raise PubErrorCustom("只有发送红包的账号可以验证码登录!")
weiboSysRun().getvercode(username=wbUobj.username)
def groupjoin(self,uid,uids,name,userid):
"""
创建群并添加成员
:param uid: 群组长uid
:param uids: 群成员uid
:param name: 群名称
:return:
"""
try:
userBossObj = WeiboUser.objects.get(uid=uid)
except WeiboUser.DoesNotExist:
raise PubErrorCustom("群组长ID不正确{}".format(uid))
userMemberObjs = []
for item in uids.split(","):
try:
userMemberObjs.append(WeiboUser.objects.get(uid=item))
except WeiboUser.DoesNotExist:
raise PubErrorCustom("群成员ID不正确{}".format(item))
#群组长关联各个群成员
print(userBossObj.session)
followClass = WeiboFollow(sessionRes=json.loads(userBossObj.session))
for item in userMemberObjs:
followClass.follow(item.uid)
#群成员关注群组长
for item in userMemberObjs:
WeiboFollow(sessionRes=json.loads(item.session)).follow(userBossObj.uid)
#添加群
wbGroupClass = WeiboGroup(sessionRes=json.loads(userBossObj.session))
res = wbGroupClass.create(name=name)
WeiboGroupModel.objects.create(**{
"group_id" : res['id'],
"name": name,
"userid":userid,
"uid":uid
})
#添加成员
wbGroupClass.join(groupid=res['id'],uids=uids)
for item in uids.split(","):
WeiboGroupMember.objects.create(**{
"group_id": res['id'],
"name" : name,
"userid":userid,
"uid" : uid,
'son_uid':item
})
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 vercodeLoginForWeibo(self, request, *args, **kwargs):
if not request.data_format.get("vercode",None):
raise PubErrorCustom("验证码不能为空!")
url="{}/wb/vercodeLoginForWeibo".format(createorder_url())
res = json.loads(requestR(url=url,method="POST",
data={"id":request.data_format['id'],"vercode":request.data_format['vercode']})\
.content.decode('utf-8'))
print(res)
if res['rescode'] != '10000':
raise PubErrorCustom(res['msg'])
return None
def vercodeLoginForWeibo(self, request, *args, **kwargs):
if not request.data.get("vercode", None):
raise PubErrorCustom("验证码不能为空!")
try:
wbUobj = WeiboUser.objects.get(id=request.data['id'])
except WeiboUser.DoesNotExist:
raise PubErrorCustom("无此账号信息!")
if wbUobj.type != '0':
raise PubErrorCustom("只有发送红包的账号可以验证码登录!")
weiboSysRun(isQueryTask=False).phonelogin(username=wbUobj.username,
vercode=request.data.get(
"vercode", None))
def responseHandlerForJson(self):
if str(self.response.get(
self.rules.get("return").get("codeKey"))) != str(
self.rules.get("return").get("ok")):
raise PubErrorCustom(
self.response.get(self.rules.get("return").get("msgKey")))
return self.rDataMapForJson()
def addGroup(self, request, *args, **kwargs):
uid = request.data['uid']
userid = request.data['userid']
print("uid:{} userid:{}".format(uid, userid))
wParams = WeiboParams.objects.get(id=1)
name = wParams.nameid
wbUobj = WeiboUser.objects.filter(userid=userid, status='0', type='1')
if not wbUobj.exists():
raise PubErrorCustom("无合法的抢红包账号!")
uids = ""
for item in wbUobj:
uids += "{},".format(item.uid)
uids = uids[:-1]
print(uids)
wbClass = weiboSysRun()
wbClass.groupjoin(uid=uid, uids=uids, name=name, userid=userid)
wParams.nameid += 1
wParams.save()
def requestHandlerForJson(self):
"""
"request":{
"url":"http://localhost:8000",
"method" : "POST",
"type":"json",
},
"""
logger.info("向上游请求的值：{}".format(json.dumps(self.request_data)))
if self.rules.get("request").get("type") == 'json':
result = request(
url=self.rules.get("request").get("url"),
method=self.rules.get("request").get("method"),
json = self.request_data,
headers={
"Content-Type": 'application/json'
}
)
elif self.rules.get("request").get("type") == 'body':
result = request(
url = self.rules.get("request").get("url"),
method = self.rules.get("request").get("method"),
data=self.request_data,
)
elif self.rules.get("request").get("type") == 'params':
if self.passid == 76:
url = self.rules.get("request").get("url") + "?params={}".format(json.dumps(self.request_data))
# data['params'] = self.request_data
print(url)
result = request(
url = url,
method = self.rules.get("request").get("method"),
)
else:
result = request(
url = self.rules.get("request").get("url"),
method = self.rules.get("request").get("method"),
params = self.request_data
)
else:
raise PubErrorCustom("请求参数错误!")
try :
self.response = json.loads(result.content.decode('utf-8'))
logger.info("上游返回值：{}".format(result.content.decode('utf-8')))
except Exception as e:
raise PubErrorCustom("返回JSON错误!{}".format(result.text))
def DownOrder(self,request):
html = RedisOrderCreate().redis_get(request.query_params.get("o"))
print(html)
if not html:
raise PubErrorCustom("此订单已过期!")
else:
return HttpResponse(html, content_type='text/html')
def DF_status_save(self,request):
try:
obj = CashoutList.objects.get(id=request.data.get("id"))
obj.df_status = '1'
obj.save()
except CashoutList.DoesNotExist:
raise PubErrorCustom("无此提现明细!{}".format(request.data.get("id")))
return None
def checkToken(self, request):
try:
Users.objects.get(google_token=request.data['token'].strip())
except Users.DoesNotExist:
raise PubErrorCustom("token不存在!")
return None
def updUmark(self, request, *args, **kwargs):
try:
wbTObj = WeiboTask.objects.select_for_update().get(taskid=request.data_format['taskid'])
except wbTObj.DoesNotExist:
raise PubErrorCustom("任务不存在!")
wbTObj.umark = '0' if wbTObj.umark!='0' else '1'
wbTObj.save()
return None
def get_amount(obj):
if obj['unit'] == 'F':
# return float(Decimal(str(float(obj['value']) * 100.0)).quantize(Decimal(obj['point']))) if 'point' in obj else float(obj['value']) * 100.0
return "%.{}lf".format(int(obj['point'])) % (float(obj['value']) * 100.0) if 'point' in obj else float(obj['value']) * 100.0
elif obj['unit'] == 'Y':
# return float(Decimal(str(float(obj['value']))).quantize(Decimal(obj['point']))) if 'point' in obj else float(obj['value'])
return "%.{}lf".format(int(obj['point'])) % (float(obj['value'])) if 'point' in obj else float(obj['value'])
else:
raise PubErrorCustom("标志错误!")
def addGroup(self, request, *args, **kwargs):
if not request.data_format.get("uid",None):
raise PubErrorCustom("群组长uid不能为空！")
data={
"uid":request.data_format.get("uid",None),
"userid":request.user.userid
}
url="{}/wb/addGroup".format(createorder_url())
res = json.loads(requestR(url=url,method="POST",
data=data).content.decode('utf-8'))
print(res)
if res['rescode'] != '10000':
raise PubErrorCustom(res['msg'])
return None
def getVerCodeForWeibo(self, request, *args, **kwargs):
url="{}/wb/getVerCodeForWeibo".format(createorder_url())
res = json.loads(requestR(url=url,method="POST",data={"id":request.data_format['id']}).content.decode('utf-8'))
print(res)
if res['rescode'] != '10000':
raise PubErrorCustom(res['msg'])
return None
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 updWeiboUser(self, request, *args, **kwargs):
try:
wbUobj = WeiboUser.objects.get(id=request.data_format['id'])
except WeiboUser.DoesNotExist:
raise PubErrorCustom("无此账号信息!")
wbUobj.password = request.data_format['password']
wbUobj.status = request.data_format['status']
wbUobj.session = request.data_format['session']
wbUobj.save()
return None
def pay(self,order):
"""
生成微博支付订单
:param order: 订单表
:return:
"""
amount = float(order.amount)
if not(self.minamount <= amount <= self.maxamount):
raise PubErrorCustom("金额范围在 {}-{}".format(self.minamount,self.maxamount))
#计算单价
price = amount / self.robnumber
print(price)
if round(price,2) * self.robnumber !=amount:
raise PubErrorCustom("该金额不正确")
print("单价:{},总价{},红包个数{}".format(price,amount,self.robnumber))
wbPayClass = WeiboPay(sessionRes=json.loads(self.wbOUser.session))
url,ordercode, = wbPayClass.pay(price=price,num=self.robnumber,amount=amount)
wapurl,payordercode = wbPayClass.getPayId(url)
html = wbPayClass.createorder(wapurl)
order.isjd = '0'
order.jd_ordercode = ordercode
order.jd_payordercode = payordercode
order.jd_data = json.dumps({
"payurl": url,
"userid": self.wbOUser.userid, #码商ID
"status": "0", # 0-待支付,1-已支付,未发红包,2-已发红包,3-红包被抢
"num": self.robnumber, # 红包个数
"ok_num": 0, # 已抢个数
"run_username": [], # 抢红包的人的集合
})
order.save()
self.payafter(order,self.wbOUser.session)
return html
def BalQueryTest(self):
if not self.data.get("businessid"):
raise PubErrorCustom("商户ID为空!")
# user = AccountBase(userid=self.user.userid,amount=1).query()
ok_bal = self.get_ok_bal()
return {
"data": {
"bal": round(float(self.user.bal), 2),
"stop_bal": round(float(self.user.stop_bal), 2),
"ok_bal": round(ok_bal, 2)
}
}
def __init__(self, data, ip=None, islock=False, isip=True):
print(ip)
self.data = data
if islock:
try:
self.user = Users.objects.select_for_update().get(
userid=self.data.get("businessid"))
except Users.DoesNotExist:
raise PubErrorCustom("无效的商户!")
else:
try:
self.user = Users.objects.get(
userid=self.data.get("businessid"))
except Users.DoesNotExist:
raise PubErrorCustom("无效的商户!")
paypass = self.get_paypasslinktype()
if not len(paypass):
raise PubErrorCustom("通道暂未开放!")
if len(paypass) > 1:
raise PubErrorCustom("代付通道不允许设置多通道!")
self.paypasslinktype = paypass[0]
#T0提现 90%
self.t0Tx = 0.8
if isip:
if ip not in ['47.75.120.33']:
data = RedisCaCheHandler(
method="filter",
serialiers="WhiteListModelSerializerToRedis",
table="whitelist",
filter_value={
"userid": self.user.userid
}).run()
if not len(data):
raise PubErrorCustom("拒绝访问!")
isIpValid = False
for item in data[0]['dfobj'].split(','):
if str(item) == str(ip):
isIpValid = True
break
if not isIpValid:
raise PubErrorCustom("拒绝访问!")