def get(self, request, *args, **kwargs):
# 获取结果接口
red = RedisX()
rc1 = RiskControl1()
# 获取需要获取的申请人apply_id 此时是1.0版本的apply_id
apply_id = request.query_params.get("apply_id")
logger.info("apply_id_1: %s" % apply_id)
# 拼装返回正在审核中的返回结果
not_ok_data = {"status": 1, "res_data": {"result": 100, "result_message": "审核中"}, "message": "操作成功"}
# 取得redis中的状态信息
redis_status = red.get(apply_id)
if redis_status:
redis_status = json.loads(redis_status)
apply_id_first_req = red.get("%s_first_req" % apply_id)
if apply_id_first_req:
time_interval = int(time.time())-int(apply_id_first_req)
if time_interval > 180:
redis_status["status"] = "OK"
else:
red_ret = red.set("%s_first_req" % apply_id, int(time.time()))
else:
apply_id_2 = "Error%s" % int(time.time() * 1000)
redis_status = {"status": "OK", "apply_id_2_0": apply_id_2}
logger.error("ObtainCreditResultView apply_id_1:%s redis_status: %s " % (apply_id, redis_status))
# 如果redis状态表示审核完成, 调用1.0获取结果接口, 透传返回信息
if redis_status.get("status") == "OK":
ret_data = rc1.do_request_1_result(request.query_params)
logger.info("1.0 result go back, data is: %s" % ret_data)
return JSONResponse(ret_data)
# redis状态表示审核中(未完成), 直接返回审核中
else:
return JSONResponse(not_ok_data)
def post(self, request, *args, **kwargs):
# 接收2.0系统审核完成结果接口, 触发此接口代表2.0审核任务完成
red = RedisX()
req_data = json.loads(request.body)
logger.info("2.0 callback data is: %s" % req_data)
# 获取2.0的apply_id
apply_id_2 = req_data.get("apply_id")
logger.info("apply_id_2: %s"% apply_id_2)
# 在redis中查得对应的1.0的apply_id
apply_id_1 = red.get(apply_id_2)
if not apply_id_1:
apply_id_1 = "Error%s" % int(time.time() * 1000)
logger.info("apply_id_1: %s" % apply_id_1)
# 拿到redis中存储的审核状态
redis_status_json = red.get(apply_id_1)
logger.info("receive result redis data is: %s" % redis_status_json)
if not redis_status_json:
redis_status_json = json.dumps({"status": "RUNNING", "apply_id_2_0": apply_id_2})
redis_status = json.loads(redis_status_json)
redis_status.update({"status": "OK"})
# 修改状态为OK
red.set(apply_id_1, json.dumps(redis_status))
res_data = {
"status": 1,
"message": "结果接收成功",
"resData": req_data,
}
# 状态返回给2.0系统 代表审核结果接收成功
return JSONResponse(res_data)
def post(self, request, *args, **kwargs):
# 封装两个系统需要的数据
post_data = json.loads(request.body)
rc1 = RiskControl1()
rc2 = RiskControl2()
# 访问风控1.0, 得到相应的apply_id和返回数据
ret_data = rc1.do_request_1_callback(json.dumps(post_data))
apply_id_1 = post_data.get("apply_id")
logger.info("apply_id_1:%s" % apply_id_1)
red = RedisX()
redis_status = red.get(apply_id_1)
if redis_status:
redis_status = json.loads(redis_status)
else:
apply_id_2 = "Error%s" % int(time.time() * 1000)
redis_status = {"status": "RUNNING", "apply_id_2_0": apply_id_2}
# 获取对应2.0的apply_id
apply_id_2 = redis_status.get("apply_id_2_0")
logger.info("apply_id_2:%s" % apply_id_2)
if apply_id_2.startswith("Error"):
redis_status["status"] = "OK"
logger.error("AsyncCallbackView apply_id_2:%s skip! apply_id_1:%s post_data:%s" % (apply_id_2, apply_id_1, post_data))
else:
time.sleep(3)
rc2.do_request_2(post_data, apply_id_2)
# 准备redis数据 包含审核状态和 apply_id映射 状态改为RUNNING
redis_status["status"] = "RUNNING"
# 储存第一个redis数据, 以apply_id1做键 redis数据转json串做值
red.set(apply_id_1, json.dumps(redis_status))
return JSONResponse(ret_data)
def post(self, request, *args, **kwargs):
# 这是第一步 拿到访问数据
post_data = request.data
rc1 = RiskControl1()
rc2 = RiskControl2()
# 封装两个系统需要的数据
data_2_0 = {
"scan_code_city": post_data.get("scan_code_city", ""),
"san_code_time": post_data.get("san_code_time", ""),
"product_code": post_data.get("product_code", ""),
"name": post_data.get("name", ""),
"mobile": post_data.get("mobile", ""),
"product_version": post_data.get("product_version", ""),
"validation_status": post_data.get("validation_status", True),
"card_id": post_data.get("card_id", ""),
"apply_id": post_data.get("apply_id", ""),
"gps_latitude": post_data.get("gps_latitude", ""),
"gps_longitude": post_data.get("gps_longitude", ""),
}
# 访问风控1.0, 得到相应的apply_id和返回数据
ret_data_list = rc1.do_request_1_apply(post_data)
apply_id_1 = ret_data_list[0]
logger.info("ApplyCreditView apply_id_1: %s" % apply_id_1)
ret_data = ret_data_list[1]
# 访问2.0 得到相应的apply_id
apply_id_2 = rc2.do_formal_request(data_2_0)
if apply_id_2:
logger.info("ApplyCreditView apply_id_2: %s" % apply_id_2)
else:
apply_id_2 = "Error%s" % int(time.time()*1000)
logger.error("ApplyCreditView apply_id_2: %s" % apply_id_2)
red = RedisX()
# 准备redis数据 包含审核状态和 apply_id映射
redis_status = {
"status": "RUNNING",
"apply_id_2_0": apply_id_2
}
# 储存第一个redis数据, 以apply_id1做键 redis数据转json串做值
red.set(apply_id_1, json.dumps(redis_status))
# 储存第二个redis数据, apply_id2与apply_id1的映射
# redis两条数据保证通过任意apply_id可以找到另一个apply_id
red.set(apply_id_2, apply_id_1)
# 返回1.0返回信息 表示审核任务提交状况
return JSONResponse(json.loads(ret_data))
def __init__(self):
self.red = RedisX()
class RiskControl2(object):
def __init__(self):
self.red = RedisX()
def do_formal_request(self, data2):
card_id = data2.get("card_id")
res_date = {"status": 0, "message": "操作失败"}
try:
starttime = time.time()
logger.info("do_request_2_apply data:%s" % data2)
response = requests.post(URL_2_0_FORMAL, headers=HEADERS, data=json.dumps(data2))
endtime = time.time()
loggertime.info("do_request_2_apply time: %s" % (endtime - starttime))
self.red.ping()
if response.status_code == 200:
res_date = json.loads(response.content)
logger.info("do_request_2_apply response: %s" % res_date)
apply_id = res_date.get("res_data").get("apply_id")
logger.info("Do 2.0 formal request success, apply_id is: %s" % apply_id)
else:
logger.error("Do 2.0 formal request failed, status code is not 200, card_id is: %s" % card_id)
except Exception as e:
logger.error(e.message)
return res_date
def do_request_2(self, data):
data_identity = data.get('data_identity')
res_date = {"status": 0, "message": "操作失败"}
try:
response = ''
if data_identity == "bank_card_upload":
logger.info("Do request to 2.0, flowchart is: %s, data is: %s" % (data_identity, data))
starttime = time.time()
response = requests.post(URL_2_0_BANKCARD, headers=HEADERS, data=json.dumps(data))
endtime = time.time()
loggertime.info("do_request_2_bank_card_upload time: %s" % (endtime - starttime))
logger.info("bank_card_upload response is: %s, flowchart is: %s" % (response.content, data))
elif data_identity == "email_dig_upload":
logger.info("Do request to 2.0, flowchart is: %s, data is: %s", data_identity, data)
starttime = time.time()
response = requests.post(URL_2_0_EMAIL, headers=HEADERS, data=json.dumps(data))
endtime = time.time()
loggertime.info("do_request_2_email_dig_upload time: %s" % (endtime - starttime))
logger.info("email_dig_upload response is: %s, flowchart is: %s" % (response.content, data))
elif data_identity == "zm_dig_upload":
logger.info("Do request to 2.0, flowchart is: %s, data is: %s", data_identity, data)
starttime = time.time()
response = requests.post(URL_2_0_ZM, headers=HEADERS, data=json.dumps(data))
endtime = time.time()
loggertime.info("do_request_2_zm_dig_upload time: %s" % (endtime - starttime))
logger.info("zm_dig_upload response is: %s, flowchart is: %s" % (response.content, data))
elif data_identity == "accumulation_fund_upload":
logger.info("Do request to 2.0, flowchart is: %s, data is: %s", data_identity, data)
starttime = time.time()
response = requests.post(URL_2_0_GJJ, headers=HEADERS, data=json.dumps(data))
endtime = time.time()
loggertime.info("do_request_2_accumulation_fund_upload time: %s" % (endtime - starttime))
logger.info("accumulation_fund_upload response is: %s, flowchart is: %s" % (response.content, data))
elif data_identity == "operator_dig_upload":
phone_remain = data.get("phone_remain", None)
if phone_remain:
data["phone_remain"] = float(phone_remain)
logger.info("Do request to 2.0, flowchart is: %s, data is: %s", data_identity, data)
starttime = time.time()
response = requests.post(URL_2_0_OPERATOR, headers=HEADERS, data=json.dumps(data))
endtime = time.time()
loggertime.info("do_request_2_operator_dig_upload time: %s" % (endtime - starttime))
logger.info("operator_dig_upload response is: %s, flowchart is: %s" % (response.content, data))
elif data_identity == "final_upload":
logger.info("Do request to 2.0, flowchart is: %s, data is: %s", data_identity, data)
starttime = time.time()
response = requests.post(URL_2_0_FINAL, headers=HEADERS, data=json.dumps(data))
endtime = time.time()
loggertime.info("do_request_2_final_upload time: %s" % (endtime - starttime))
logger.info("final_upload response is: %s, flowchart is: %s" % (response.content, data))
res_date = json.loads(response.content)
except Exception as e:
logger.error(e.message)
return res_date
def __init__(self, apply_id, **kwargs):
super(CacheContext, self).__init__(apply_id, **kwargs)
self.data_identity = ''
self.red = RedisX()
self.cache_base = MongoBase(collection_name=CACHE_BASE_NAME)
class CacheContext(BaseContext):
"""
这是一个储存原始数据的Mongo集合
以受信人为文档标识
每一组数据包含:
1.数据源直接返回的查询结果
2.请求数据源用到的参数
3.查询时间
储存模式:缓存模式 时效24h
"""
def __init__(self, apply_id, **kwargs):
super(CacheContext, self).__init__(apply_id, **kwargs)
self.data_identity = ''
self.red = RedisX()
self.cache_base = MongoBase(collection_name=CACHE_BASE_NAME)
def save(self):
"""save kwargs to backend"""
self.red.ping()
self.data_identity = self.kwargs.keys()[0]
insert_id = self.cache_base.save(self.kwargs)
self.kwargs = {}
o_id = insert_id.inserted_id
key = self.apply_id + ':' + self.data_identity
if not self.red.set(key, o_id):
raise Exception("redis cache_base %s key error!" % key)
self.data_identity = ""
def get(self, key):
"""get value for key"""
self.red.ping()
redis_key = self.apply_id + ':' + key
o_id = self.red.get(redis_key)
if o_id:
query = {'_id': ObjectId(o_id)}
ret = self.cache_base.search(query)
return ret
else:
return None
def delete_cache(self, key):
"""get value for key"""
self.red.ping()
redis_key = self.apply_id + ':' + key
ret = self.red.delete(redis_key)
return ret
def sadd_async(self, value):
self.red.ping()
key = self.apply_id + '__data_identity'
self.red.sadd(key, value)
self.red.expire(name=key)
def delete_async(self):
self.red.ping()
key = self.apply_id + '__data_identity'
ret = self.red.delete(key)
return ret
def smembers_async(self):
self.red.ping()
key = self.apply_id + '__data_identity'
ret = self.red.smembers(key)
return ret
def srem_async(self, value):
self.red.ping()
key = self.apply_id + '__data_identity'
ret = self.red.srem(key, value)
return ret
def sadd_async_args(self, data_identity, value):
self.red.ping()
key = self.apply_id + '__' + data_identity + '__args'
self.red.sadd(key, value)
self.red.expire(name=key)
def smembers_async_args(self, data_identity):
self.red.ping()
key = self.apply_id + '__' + data_identity + '__args'
ret = self.red.smembers(key)
return ret
def srem_async_args(self, data_identity, value):
self.red.ping()
key = self.apply_id + '__' + data_identity + '__args'
ret = self.red.srem(key, value)
return ret