async def prepay(self, ktv_id, openid, order_id, fee=0):
try:
params = {
"op": "fastpay",
'erpid': order_id,
"ktvid": ktv_id, #这个参数是一定不能丢的
"paytype": "WX",
"action": "GZH",
"other":'namegame',
"data": json.dumps({
"paraBody": '您支付了%s' % (fee / 100),
"paraTotalFee": fee,
"paraOpenId": openid,
}),
}
logging.error('prepay params: %s' % params)
url = 'http://pay.ktvsky.com/wx'
http_client = utils.get_async_client()
request = httpclient.HTTPRequest(url_concat(url, params), method='POST', body='',
headers={'Connection': 'keep-alive'}, connect_timeout=10,
request_timeout=10)
r = await utils.fetch(http_client, request)
r = json.loads(bytes(r.body).decode())
logging.info(r)
ctrl.web.update_namegame_order(data=dict(order_id=order_id, state=3, wx_pay_id=r['order']))
return r
async def _request_orders(self, ktv_id, term_id, pay_type, start_date, end_date, page, page_size, has_pn=None):
if pay_type == 'wechat':
url = APIS['account_order'].format(ktv_id=ktv_id)
elif pay_type == 'alipay':
url = APIS['ali_account_order'].format(ktv_id=ktv_id)
elif pay_type == 'pos':
url = APIS['pos_account_order'].format(ktv_id=ktv_id)
elif pay_type == 'deposit':
url = APIS['withdraw_history'].format(ktv_id=ktv_id)
else:
raise utils.APIError(errcode=10001)
http_client = utils.get_async_client()
params = {
'term_id': term_id,
'start_date': start_date,
'end_date': end_date
}
if has_pn:
params.update({
'pn': page,
'size': page_size,
'has_pn': True
})
request = utils.http_request(url_concat(url, params))
response = await http_client.fetch(request)
orders = json.loads(response.body.decode())
return orders
async def pay_query(self, order_id, loop=1):
logging.info("\n\nloop=%s, order_id=%s"%(loop, order_id))
order = ctrl.web.get_by_order(order_id)
if not order:
raise utils.APIError(errcode=10001)
try:
params = {
"op": "query",
"ktvid": order['ktv_id'], # 专用于分享订单的打赏
"paytype": 'WX', # ALI or WX
"data": json.dumps({
"paraOutTradeNo": order['wx_pay_id'],
}),
}
url = 'http://pay.ktvsky.com/wx'
http_client = utils.get_async_client()
request = httpclient.HTTPRequest(url_concat(url, params), method='POST', body='',
headers={'Connection': 'keep-alive'}, connect_timeout=10, request_timeout=10)
res = await utils.fetch(http_client, request)
res = json.loads(bytes(res.body).decode())
logging.info(res)
if utils.is_success_pay('wx', res):
ctrl.web.update_namegame_order(data=dict(order_id=order_id, state=2, wx_pay_id=res['transaction_id']))
res['is_pay'] = 1
return res
async def update_bank_info(self, ktv_id, args):
http_client = utils.get_async_client()
params = urlencode(args)
request = utils.http_request(APIS['bank'].format(ktv_id=ktv_id), method='POST', body=params)
response = await http_client.fetch(request)
response = json.loads(response.body.decode())
return response
async def get_ktv_pos(self, ktv_id):
req_url = APIS['ktv_pos'].format(ktv_id=ktv_id)
http_client = utils.get_async_client()
request = utils.http_request(req_url)
response = await http_client.fetch(request)
pos_list = json.loads(response.body.decode())
return pos_list
async def insert_ser_info(self, **params):
ktv_ser_info = self.api.insert_ser_info(**params)
tradeno = ktv_ser_info['id']
params_api = {'op': 'savektvpayinfo', 'tradeno': tradeno}
http_client = utils.get_async_client()
http_request = utils.http_request(
url_concat(APIS['sub_ktv_service_info'], params_api))
res = await http_client.fetch(http_request)
async def get_ser_info(self, ktv_id):
params = {'ktvid': ktv_id, 'op': 'getktvpayinfo'}
http_client = utils.get_async_client()
http_request = utils.http_request(
url_concat(APIS['ktv_service_info'], params))
response = await http_client.fetch(http_request)
response = json.loads(response.body.decode())
return response['result']
async def get_order_by_orderid(self, pay_type, order_id):
http_client = utils.get_async_client()
params = {'order_id': order_id}
request = utils.http_request(
url_concat(APIS['order'].format(pay_type=pay_type), params))
response = await http_client.fetch(request)
order_info = json.loads(response.body.decode())
return order_info['order']
async def update_ktv(self, ktv_id, args):
http_client = utils.get_async_client()
req_url = '{url}/kinfo/{ktv_id}'.format(url=COMMON_URL, ktv_id=ktv_id)
params = json.dumps(args)
request = utils.http_request(req_url, method='PUT', body=params)
response = await http_client.fetch(request)
response = json.loads(response.body.decode())
return response
async def withdraw_money(self, ktv_id, is_extra=0):
http_client = utils.get_async_client()
params = urlencode({
'is_extra': is_extra
})
http_request = utils.http_request(APIS['withdraw'].format(ktv_id=ktv_id), method='POST', body=params)
response = await http_client.fetch(http_request)
response = json.loads(response.body.decode())
return response
async def post_pay(self, store_id, order_no, bill_id, auth_code, paytype):
key = 'query_order_%s_%s' % (order_no, bill_id)
self.ctrl.rs.delete(key)
if bill_id:
orders = self.get_bills_ctl(store_id, [bill_id])
else:
orders = self.get_orders(store_id, [order_no])
if not orders:
raise utils.APIError(errcode=10001)
order = orders[0]
total_fee = order['money']
url = WX_PAY_URL.format(paytype=paytype)
pay_params = {
'op':
'fastpay',
'ktvid':
store_id,
'date':
str(datetime.datetime.now().date()),
'action':
'MICROPAY',
'data':
json.dumps({
'ktv_id': store_id,
'erp_id': order_no,
'paraTotalFee': total_fee if not options.debug else 1,
'paraAuthCode': auth_code,
'paraBody': 'body',
'paraBillCreateIp': '',
}),
'erp_id':
order_no,
'time':
int(datetime.datetime.now().timestamp())
}
try:
http_client = utils.get_async_client()
request = utils.http_request(url_concat(url, pay_params),
method='POST',
body='')
res = await utils.fetch(http_client, request)
res = json.loads(res.body.decode())
logging.info('query order result: %s' % res)
return res
except Exception as e:
logging.error(e)
return {}
async def _get_openid(self, code):
key = 'code_%s' % code
v = ctrl.rs.get(key)
if v:
return v.decode()
url = FETCH_OPENID_URL.format(appid=WX_CONF['appid'],
secret=WX_CONF['appsecret'],
code=code)
http_client = utils.get_async_client()
request = utils.http_request(url)
response = await http_client.fetch(request)
response = json.loads(response.body.decode())
logging.info(response)
ctrl.rs.set(key, response['openid'], 10 * 60)
return response['openid']
async def get_user_info(self, openid):
try:
access_token = await utils.async_common_api(
'/wx/token', dict(flag=1))
except Exception as e:
logging.error(e)
raise
url = FETCH_USERINFO_URL_V2.format(
access_token=access_token['accec_token'], openid=openid)
http_client = utils.get_async_client()
request = utils.http_request(url)
response = await http_client.fetch(request)
response = json.loads(response.body.decode())
return response
async def get_per_data(self, ktv_id, stm='', etm=''):
params = {'stm': stm, 'etm': etm}
http_client = utils.get_async_client()
http_request = self.gen_request_ctl('getPayWayInfo', ktv_id, params)
key = self.get_pay_prop_key_ctl(ktv_id, stm, etm)
data = self.ctrl.rs.get(key)
if data:
return pickle.loads(data)
try:
response = await http_client.fetch(http_request)
data = json.loads(response.body.decode())
assert int(data['code']) == 1
self.ctrl.rs.set(key, pickle.dumps(data), A_MINUTE)
return data
except:
return {}
async def pay_query(self,
store_id,
order_no,
bill_id,
paytype='wx',
loop=1):
logging.info('query order loop %s' % loop)
key = 'query_order_%s_%s' % (order_no, bill_id)
v = self.ctrl.rs.get(key)
if v:
v = eval(v)
return v
is_room = False
orders = []
if bill_id:
orders = self.get_bills_ctl(store_id, [bill_id])
else:
orders = self.get_orders(store_id, [order_no])
if not orders:
raise utils.APIError(errcode=10001)
order = orders[0]
if bill_id and order['bill_no'].startswith('KT'):
is_room = True
url = WX_PAY_URL.format(paytype=paytype)
pay_params = {
'op': 'query',
'ktvid': store_id,
'date': str(datetime.datetime.now().date()),
'action': 'MICROPAY',
'data': json.dumps({'paraOutTradeNo': order['pay_id']}),
'erp_id': order_no,
'time': int(datetime.datetime.now().timestamp())
}
try:
http_client = utils.get_async_client()
request = utils.http_request(url_concat(url, pay_params),
method='POST',
body='')
res = await utils.fetch(http_client, request)
res = json.loads(res.body.decode())
logging.info('query order order_no: %s, bill_id: %s result: %s' %
(order_no, bill_id, res))
if utils.is_success_pay(paytype, res):
pl = self.ctrl.rs.pipeline(transaction=True)
pl.set(key, res).expire(key, 15 * 60).execute()
self.success_pay_ctl(store_id, order_no, bill_id, paytype,
is_room)
elif loop > 0:
IOLoop.current().add_timeout(time.time() + 10,
self.pay_query_ctl, store_id,
order_no, bill_id, paytype,
loop - 1)
return res
except Exception as e:
logging.error(e)
if loop > 0:
IOLoop.current().add_timeout(time.time() + 10,
self.pay_query_ctl, store_id,
order_no, bill_id, paytype,
loop - 1)
return {}
async def get_bank_info(self, ktv_id):
http_client = utils.get_async_client()
request = utils.http_request(APIS['withdraw_account'].format(ktv_id=ktv_id))
response = await http_client.fetch(request)
bank_info = json.loads(response.body.decode())
return bank_info
