def insert_block_chain_info(self, user_id: str, instance_id: str,
record_type: int, on_chain_info: dict) -> bool:
try:
# compute information hash
hash_data = self.info_to_hash(on_chain_info)
# send transaction
transaction_response = self.send_transaction(hash_data)
except TypeError as type_error:
raise_logger(type_error, 'rs', 'error')
return False
except Exception as send_error:
raise_logger(send_error, 'rs', 'error')
return False
hash_hex = "0x" + hash_data
# store information
with MysqlTools().session_scope() as session:
BlockChainInfoModel.store(
session,
user_id,
instance_id,
record_type,
hash_hex,
on_chain_info,
transaction_hash=transaction_response['tx_hash'],
on_chain_at=transaction_response['timestamp'],
game_serial=on_chain_info.get("game_serial", ""),
participate_id=on_chain_info.get("id", "-1"))
return True
def rpc_post(self,
api,
params=None,
headers=None,
form=None,
unit=None,
format_str=None):
try:
data = None
url = None
if format_str:
data = super_json_dumps(params)
else:
if params:
data = json.dumps(params)
elif form:
data = form
if unit == "wallet":
url = self.rpc_base_wallet_url + api
response = requests.post(url,
data=data,
headers=headers,
timeout=3600)
if response.status_code in (200, 201):
return response.json()
else:
if api != "/unlock":
raise Exception("http code: " + str(response.status_code))
except Exception as e:
raise_logger("Exception rpc_post: " + str(e), "wallet", "error")
return {}
def send_vcode_by_email(self, vcode_key):
email_config = get_sms_email(vcode_key)
if email_config == {}:
self.return_error(35034)
redis = RedisTools()
lock = redis_lock.Lock(redis.redis_conn, 'send_vcode', expire=60)
try:
if lock.acquire():
vcode = self.generate_verification_code()
# 发送验证码
send_email_config = get_sms_email("send_email_config")
subject = email_config['email_subject']
send_mail(vcode, send_email_config['user'], send_email_config['pwd'], email_config['email'], subject,
send_email_config['smtp_server'], send_email_config['smtp_port'])
redis_key = self.get_sms_email_key(email_config['redis_key'], vcode)
redis.set(redis_key, vcode, ex=email_config['redis_second'])
status = {
"status": "true"
}
lock.release()
return status
except HTTPException as e:
raise e
except Exception as err:
exceptions = traceback.format_exc()
if exceptions:
exception_list = exceptions.split(':')
if not exception_list[0] == 'NoneType':
for i in exception_list:
for j in i.split("\n"):
raise_logger(j, 'rs', 'error')
self.return_error(30035)
def wrapped_func(*args, **kwargs):
if log_server_env != "pd" and not whether_on_server:
func_data = func(*args, **kwargs)
return self.get_return_msg(func_data)
else:
try:
func_data = func(*args, **kwargs)
return self.get_return_msg(func_data)
except HTTPException as he:
raise he
except:
try:
exceptions = traceback.format_exc()
exception_list = exceptions.split('File ')
exc_list = exception_list[2].replace(
'"', "").split(",")[0].split(os.path.sep)
exc_desc = exc_list[-2] + "/" + exc_list[-1]
exc_log_list = exception_list[-1].replace(
"\n", " ").replace('"', "").split(" ")
exc_log_list = [msg for msg in exc_log_list if msg]
exc_file = " ".join(exc_log_list[:3]).replace(',', "")
exc_log = " ".join(exc_log_list[4:])
raise_logger(exc_log, "rs", "error", file=exc_file)
except:
exc_desc = ""
return self.get_return_msg(exc_desc, False)
def wrapped_func(*args, **kwargs):
try:
func_data = func(*args, **kwargs)
if self.cover_body == COVER_BODY_TYPE_SUCCESS:
return make_body_return_success(func_data)
else:
return func_data
except HTTPException as e:
if not self.cover_http_exception:
raise e
else:
exceptions = traceback.format_exc()
if exceptions:
exception_list = exceptions.split(':')
if not exception_list[0] == 'NoneType':
for i in exception_list:
for j in i.split("\n"):
raise_logger(j, 'rs', 'error')
return_msg = self.get_return_msg()
return return_msg
except Exception:
exceptions = traceback.format_exc()
if exceptions:
exception_list = exceptions.split(':')
if not exception_list[0] == 'NoneType':
for i in exception_list:
for j in i.split("\n"):
raise_logger(j, 'rs', 'error')
return_msg = self.get_return_msg()
return return_msg
def unauthorized(error):
raise_logger(error, 'rs', 'error')
response = jsonify()
response.headers["Error_Code"] = 401
response.headers["Error_Desc"] = str(error)
response.headers["Error_Msg"] = str(error)
response.status_code = 401
return response
def not_found(error):
raise_logger(error, 'rs', 'info')
response = jsonify()
response.headers["Error_Code"] = 404
response.headers["Error_Desc"] = str(error)
response.headers["Error_Msg"] = str(error)
response.status_code = 404
return response
def method_not_allow(error):
raise_logger(error, 'rs', 'error')
response = jsonify()
response.headers["Error_Code"] = 405
response.headers["Error_Desc"] = str(error)
response.headers["Error_Msg"] = str(error)
response.status_code = 405
return response
def server_error(error):
raise_logger(error, 'rs', 'error')
response = jsonify()
response.headers["Error_Code"] = 400
response.headers["Error_Desc"] = str(error)
response.headers["Error_Msg"] = str(error)
response.status_code = 400
return response
def dice_chip_in_new(self, user_id, user_channel_id, coin_id, bet_amount,
user_dice):
change_type_31 = '31' # 扣款
change_type_32 = '32' # 返还
change_type_33 = '33' # 中奖
with MysqlTools().session_scope() as session:
# 查询用户资产
account_service = AccountService()
user_info = account_service.get_inner_user_account_by_token(
session, user_id, coin_id)
if isinstance(user_info, int):
if user_info == 20001:
return self.return_error(20001)
balance = get_decimal(user_info.get("balance"),
digits=8,
decimal_type="down")
# 账户余额 < 需要下注金额
bet_number = get_decimal(bet_amount, digits=4, decimal_type="down")
if balance < bet_number:
return self.return_error(60005)
dice_serial = dice_generate_phase()
dice_time = get_timestamp()
dice_part_in_model = DiceParticipateInModel(
dice_serial=dice_serial,
user_id=user_id,
user_dice=user_dice,
channel=user_channel_id,
bet_number=bet_number,
bet_token=coin_id,
reward_token=coin_id,
reward_quantity=bet_number,
dice_timestamp=dice_time)
session.add(dice_part_in_model)
session.flush()
# 提交扣款申请
dice_part_id = dice_part_in_model._id
result = account_service.do_bet(
session, user_id, coin_id, bet_number,
'dice_bet' + str(dice_part_in_model._id), 1, dice_serial,
user_channel_id, change_type_31)
if result != 0:
session.rollback()
raise_logger("do_bet result" + str(result), "game_bet_in",
"info")
session.commit()
return {
'user_dice':
user_dice,
'dice_timestamp':
timestamp_to_str(dice_time, format_style="%Y-%m-%d %H:%M:%S"),
'dice_id':
str(dice_part_id),
'dice_serial':
dice_serial
}
def get_argument_dict(self,
must_keys=None,
format_str=False,
format_keys=True,
format_eval=True,
verify_timeliness=True,
verify_key=None,
expire_time=None,
check_token=True,
invariable_key=False,
api_type="invest"):
"""
:param must_keys: must_keys=["aa", "bb"] 判断出入列表里的值,是否在请求参数里,没有报错
:param format_str: 是否需要把所有int类型,强转成字符串
:param format_eval: 是否开启 把字符串 '["a","b"]' '{"a":1,"b":"1"}' 强转回list dict
:param format_keys: 是否开启 把key的值 转为全小写
:param verify_timeliness: 是否做请求时效校验，默认需要校验
:param verify_key: 请求时效校验所包含的key，默认不包含key的校验
:param expire_time: 请求实效校验的时效
:param check_token: 是否检查token,存在token,则必须检查
:param invariable_key: 用户未登录情况下,使用指定密钥解密
:param api_type: invest/投资用户前端和移动端 borrow/管理后台
:return:
"""
# 获取参数字典
ip = request.remote_addr
white_list = get_white_list()
if ip not in white_list:
self.return_error(100000)
request_args = {}
if verify_timeliness and verify_key and expire_time and invariable_key:
try:
request_args = self.decrypt_request_content(
check_token=check_token, api_type=api_type)
print("request_args解析后:\n", request_args)
except Exception as error:
raise_logger(str(error))
self.return_error(10006, error_msg="解析参数出现错误,请重新尝试")
else:
request_args = self.get_request_content()
request_args = formate_args(request_args, format_str, format_keys,
format_eval)
# 判断必填字段
if must_keys:
for key in must_keys:
if key not in request_args:
raise_logger("请求缺少 [%s] 参数" % key, error_code=20003)
self.return_error(20003)
return request_args
def rpc_get(self, api, unit=None):
try:
url = None
if unit == "wallet":
url = self.rpc_base_wallet_url + api
response = requests.get(url, timeout=3600)
if response.status_code in (200, 201):
return response.json()
else:
raise Exception("http code: " + str(response.status_code))
except Exception as e:
raise_logger("Exception rpc_get: " + str(e), "wallet", "error")
return {}
def send_transaction(self, sign_args):
"""
推送交易
:param sign_args:
:return:
"""
base_trx_args = self.get_base_trx_args()
try:
sign_data = self.get_sign(base_trx_args, sign_args)
print("sign_data = ")
print(sign_data)
transaction_res = self.ec.http_push_transaction(sign_data)
except Exception as e:
raise_logger("Exception send_transaction: " + str(e), "wallet",
"error")
return {"err": str(e)}
return transaction_res
def post(self):
request_data = self.get_argument_dict(
must_keys=['info_type', 'user_id'])
info_type = request_data.get("info_type")
instance_id = request_data.get("instance_id", "")
user_id = request_data.get("user_id")
participate_id = request_data.get("participate_id", "")
timezone = -request_data.get("timezone")
info_type = str(info_type)
try:
info = BlockChainInfoService().get_info_detail(
info_type, instance_id, user_id, participate_id, timezone)
return info
except ValueError:
self.return_error(20003)
except Exception as error:
raise_logger(error, 'rs', 'error')
self.return_error(20002)
def lottery_callback(cls, game_instance_id, block_no, block_hash, timestamp, received_time):
"""
一元夺宝 内部回调
:return:
:param game_instance_id: 项目id int类型
:param block_no: 区块号 int类型
:param block_hash: 区块hash
:param timestamp: 区块生成时间
:param received_time: 区块hash值不可逆时间
"""
# timestamp = str(timestamp).replace("T"," ")[:-4]
# received_time = str(received_time).replace("T"," ")[:-4]
try:
res = GamePublishLotteryServie().check_game_sold_out_by_eos(game_instance_id, block_no, block_hash, timestamp, received_time)
if res is True:
return _ONE
except Exception as e:
raise_logger("lottery_callback" + str(e), "wallet", "error")
return _ZERO
def automatic_release(self, session, template_id):
# now = int(time.time())
# time_struct = time.localtime(now)
# str_time = time.strftime("%Y-%m-%d %H:%M:%S", time_struct)
template_id = 1
str_time = get_utc_now()
with MysqlTools().session_scope() as session:
template_info = session.query(InstantGameTemplateModel). \
filter(InstantGameTemplateModel._id == template_id).first()
# 判断存在在"启用"状态 且 自动发布的模板
if template_info.template_status == 1 and template_info.auto_release == 1:
# 查询btc 与 usdt 转换比
btc_usdt_rate = get_exchange_rate(
template_info.reward_token)['price']
if btc_usdt_rate > template_info.need_ceiling or btc_usdt_rate < template_info.need_floor:
raise_logger("automatic_release out of rate", 'rs',
'error')
return {"status": False}
need = btc_usdt_rate * template_info.reward_quantity
game_serial = generate_phase(str(template_info.phase_prefix))
digital_instance_model = InstantGameInstanceModel(
template_id=template_id,
game_serial=game_serial,
game_title=template_info.game_title,
bet_token=template_info.bet_token,
bet_unit=template_info.bet_unit,
support_token=template_info.support_token,
reward_token=template_info.reward_token,
reward_quantity=template_info.reward_quantity,
handling_fee=template_info.handling_fee,
game_describe=template_info.game_describe,
experience=template_info.experience,
merge_threshold=template_info.merge_threshold,
max_bet_ratio=template_info.max_bet_ratio,
release_time=str_time,
need=int(need),
status=-1,
release_type=1,
chain_status=0)
session.add(digital_instance_model)
# session.flush()
session.commit()
return {"status": True}
def lottery_adduce(cls, game_instance_id, base_time_stamp, lottery_block_add=60, confirm_block_add=200):
"""
一元夺宝 外部引用
:param game_instance_id: 游戏实例id 必传
:param base_time_stamp: 传时间戳 float或decimal类型 必须保留小数点后3位 必传
:param lottery_block_add: 根据时间戳找到基础参照区块,加上该参数,即开奖区块号
:param confirm_block_add: 根据开奖区块号,加上该参数,就是确认区块号,脚本找到该区块,即公布开奖,脚本回调 lottery_callback
:return:
"""
lottery_block_add -= _ONE # 根据基础块找,所以需要减1
game_instance_id = int(game_instance_id)
try:
with MysqlTools().session_scope() as session:
lottery_block_info = session.query(GameGetLotteryBlockInfoEosModel).filter(GameGetLotteryBlockInfoEosModel.game_instance_id == game_instance_id).first()
if lottery_block_info:
base_block_num = lottery_block_info.base_block_num
lottery_block = lottery_block_info.block_num
confirm_block = lottery_block_info.confirm_block_num
else:
base_block_num = game_instance_id * -1
lottery_block = lottery_block_add
confirm_block = confirm_block_add
lottery_block_info = GameGetLotteryBlockInfoEosModel(
game_instance_id=game_instance_id,
base_block_num=base_block_num,
base_time_stamp=base_time_stamp,
block_num=lottery_block,
confirm_block_num=confirm_block
)
session.add(lottery_block_info)
session.commit()
return {
"game_instance_id": game_instance_id,
"base_block_num": base_block_num,
"block_num": lottery_block,
"confirm_block": confirm_block
}
except Exception as e:
raise_logger("lottery_adduce" + str(e), "wallet", "error")
return False
def http_post(self, params=None, headers=None, api=None):
try:
data = None
url = self.http_base_url
if api:
url += "/v1/chain/" + api + "?apikey=" + self.http_api_key
if params:
data = super_json_dumps(params)
response = requests.post(url,
data=data,
headers=headers,
timeout=3600)
if response.status_code in (200, 201):
return response.json()
else:
raise Exception("http code: " + str(response.status_code))
except Exception as e:
raise_logger("Exception http_post: " + str(e), "wallet", "error")
return {}
def http_get(self, params=None, headers=None, api=None):
try:
url = self.http_base_url
if not api:
if params:
module_action = "/api?module=%(module)s&action=%(action)s&" % params + "apikey=" + self.http_api_key
for k, v in params.items():
if k not in ["module", "action"]:
module_action += "&" + k + "=" + str(v)
url += module_action
else:
url += "/v1/chain/" + api + "?apikey=" + self.http_api_key
response = requests.get(url, headers=headers, timeout=3600)
if response.status_code in (200, 201):
return response.json()
else:
raise Exception("http code: " + str(response.status_code))
except Exception as e:
raise_logger("Exception http_get: " + str(e), "wallet", "error")
return {}
def get_base_trx_args(self):
"""
拼接基础参数
:return:
"""
base_trx_args = {}
try:
latest_block = self.ec.http_get_latest_block()
base_trx_args["chain_id"] = self.http_get_info()
base_trx_args["pub_key"] = self.eos_pub_key
base_trx_args["expiration"] = timestamp_to_str(
str_to_timestamp(latest_block["timestamp"]) +
float(self.expired_second),
format_style="%Y-%m-%dT%H:%M:%S.%f")
base_trx_args["ref_block_num"] = latest_block["block_num"]
base_trx_args["ref_block_prefix"] = latest_block[
"ref_block_prefix"]
except Exception as e:
raise_logger("Exception get_base_trx_args: " + str(e), "wallet",
"error")
return base_trx_args
def action_bet(time, user_id):
raise_logger(time)
with MysqlTools().session_scope() as session:
# 查询机器人配置纪录
robot = session.query(RobotConfigRecordModel).filter(
RobotConfigRecordModel.user_id == user_id,
RobotConfigRecordModel.bet_plan_time == time,
RobotConfigRecordModel.bet_status == 0
).first()
if robot is None:
return
if GameBetInServie().robot_bet_in(
{'game_instance_id': robot.game_instance_id,
'user_id': robot.user_id,
'conin_id': robot.pay_token,
'bet_amount': robot.bet_number,
'time_stamp': robot.time_stamp
}
) is False:
raise_logger("机器人下注失败", "game_bet_in", "info")
raise_logger("机器人下注成功", "game_bet_in", "info")
def get_argument_dict(self,
must_keys=None,
format_str=False,
format_keys=True,
format_eval=True,
check_form_token=False,
time_key_list=None):
"""
:param must_keys: must_keys=["aa", "bb"] 判断出入列表里的值,是否在请求参数里,没有报错
:param format_str: 是否需要把所有int类型,强转成字符串
:param format_eval: 是否开启 把字符串 '["a","b"]' '{"a":1,"b":"1"}' 强转回list dict
:param format_keys: 是否开启 把key的值 转为全小写
:param check_form_token: 是否校验表单中的随机字符串，所有会修改数据的请求，都应该校验！！
:param time_key_list: 转换时区的校验时间key补充字段列表
:return:
"""
# 获取参数字典
request_args = self.get_request_content()
request_args = formate_args(request_args, format_str, format_keys,
format_eval)
if get_env() != 'dev' and check_form_token:
if 'form_token' not in request_args:
self.return_error(10018)
check_url = get_user_center_conf()[get_env(
)]['base_url'] + '/transfer/' + str(request_args['form_token'])
check_result = transfer_to_platform(check_url)
if not check_result:
self.return_error(10018)
request_args.pop('form_token')
# 判断必填字段
if must_keys:
for key in must_keys:
if key not in request_args:
raise_logger("请求缺少 [%s] 参数" % key, lv="error")
self.return_error(20003)
return self.timezone_transform(request_args, time_key_list)
def add_auto_robot_config(self, dic):
if dic.get('game_serial', '') == '':
self.return_error(50000)
if dic.get('robot_numbers', '') == '':
self.return_error(50000)
if dic.get('bet_numbers', '') == '':
self.return_error(50000)
if dic.get('support_token', '') == '':
self.return_error(50000)
if dic.get('start_time', '') == '':
self.return_error(50000)
if dic.get('end_time', '') == '':
self.return_error(50000)
if dic.get('bet_min', '') == '':
self.return_error(50000)
if dic.get('bet_max', '') == '':
self.return_error(50000)
if dic.get('created_user_id', '') == '':
self.return_error(50000)
game_serial = dic['game_serial'] # 下注期数
robot_numbers = int(dic['robot_numbers']) # 机器人数量
bet_numbers = int(dic['bet_numbers']) # 总下注数量
support_token = int(dic['support_token']) # 下注币种
start_time = dic['start_time'] # 下注开始时间
end_time = dic['end_time'] # 下注结束时间
bet_min = int(dic['bet_min']) # 最小下注数量
bet_max = int(dic['bet_max']) # 最大下注数量
created_user_id = dic['created_user_id']
if robot_numbers * bet_max < bet_numbers:
self.return_error(60021)
if robot_numbers * bet_min > bet_numbers:
self.return_error(60022)
if start_time >= end_time:
self.return_error(60020)
today = datetime.datetime.strftime(datetime.datetime.utcnow(),
'%Y-%m-%d %H:%M:%S')
if start_time < today:
self.return_error(70004)
with MysqlTools().session_scope() as session:
instance = session.query(GameDigitalInstanceModel).filter(
GameDigitalInstanceModel.game_serial == game_serial,
GameDigitalInstanceModel.status ==
0).with_for_update().first()
if instance is None:
self.return_error(60001)
if instance.status != 0:
self.return_error(60000)
if bet_numbers > (instance.need - instance.bet_number):
self.return_error(60004)
if instance.support_token != -1:
if support_token != instance.support_token:
self.return_error(60018)
# 配置机器人注数
bet_arr = [bet_min] * robot_numbers
bet_numbers = bet_numbers - bet_min * robot_numbers
while bet_numbers > 0:
num = random.randint(0, len(bet_arr) - 1)
if bet_arr[num] >= bet_max:
continue
bet_arr[num] = bet_arr[num] + 1
bet_numbers = bet_numbers - 1
# 每个下注数量 bet_arr
# 时间差 秒
bet_start_time = datetime.datetime.strptime(
start_time, '%Y-%m-%d %H:%M:%S')
bet_end_time = datetime.datetime.strptime(end_time,
'%Y-%m-%d %H:%M:%S')
delta_times = bet_end_time - bet_start_time
sec = int(delta_times.seconds / 1)
time_arr = []
for i in bet_arr:
delta_time = random.randint(1, sec - 1)
bet_time = bet_start_time + datetime.timedelta(
seconds=delta_time)
time_arr.append(bet_time.strftime('%Y-%m-%d %H:%M:%S'))
time_arr.sort()
# 每个下注时间 time_arr
q = session.query(RobotAccountModel).filter(
RobotAccountModel.status == 0).with_for_update().all()
if len(q) < robot_numbers:
return self.return_error(70000)
i = 0
tokens = [0, 60]
robot_arr = []
while i < len(bet_arr):
pay_token = -1
if support_token < 0:
pay_token = random.sample(tokens, 1)[0]
robot_arr.append({
"user_id": q[i].user_id,
"nick_name": q[i].nick_name,
"bet_number": bet_arr[i],
"pay_token": pay_token,
"bet_time": time_arr[i]
})
i = i + 1
# print("bet_arr:", bet_arr)
# print("time_arr:", time_arr)
# print("robot_arr:", robot_arr)
total_bet_number = 0
time_stamp = time.time()
count = 0
try:
for robot in robot_arr:
bet_number = int(robot.get("bet_number", "0"))
if bet_number <= 0:
return self.return_error(70001)
if robot.get("user_id", "") == "":
return self.return_error(70001)
if robot.get("nick_name", "") == "":
return self.return_error(70001)
if robot.get("bet_number", "") == "":
return self.return_error(70001)
if robot.get("pay_token", "") == "":
return self.return_error(70001)
if robot.get("bet_time", "") == "":
return self.return_error(70001)
# 机器人配置时间是否 > 当前时间
today = datetime.datetime.strftime(
datetime.datetime.utcnow(), '%Y-%m-%d %H:%M:%S')
if robot['bet_time'] < today:
return self.return_error(70004)
# 添加计划 机器人配置任务 信息
bet_plan_time = datetime.datetime.strptime(
robot['bet_time'], '%Y-%m-%d %H:%M:%S')
# 累计投注数量
total_bet_number = total_bet_number + bet_number
# 修改机器人账户状态
q = session.query(RobotAccountModel).filter(
RobotAccountModel.user_id ==
robot['user_id']).with_for_update().first()
if q.status == 1:
return self.return_error(70005)
q.status = 1
# 添加机器人配置纪录
robot_config = RobotConfigRecordModel(
game_instance_id=instance._id,
game_serial=dic['game_serial'],
user_id=robot['user_id'],
nick_name=robot['nick_name'],
bet_number=int(robot['bet_number']),
pay_token=int(robot['pay_token']),
bet_plan_time=bet_plan_time,
bet_status=0,
time_stamp=time_stamp)
session.add(robot_config)
count = count + 1
if count == 100:
session.flush()
count = 0
raise_logger("add_auto_robot_config flush",
"game_publish_lottery", "info")
# print("flush")
# 添加游戏机器人配置纪录
robot_game_config_record = RobotGameConfigRecordModel(
game_instance_id=instance._id,
game_serial=game_serial,
robot_number=robot_numbers,
total_bet_number=total_bet_number,
start_of_plan_time=datetime.datetime.strptime(
start_time, '%Y-%m-%d %H:%M:%S'),
end_of_plan_time=datetime.datetime.strptime(
end_time, '%Y-%m-%d %H:%M:%S'),
status=1,
robot_bet_type=0,
created_user_id=created_user_id,
time_stamp=time_stamp)
session.add(robot_game_config_record)
session.flush()
session.commit()
return {'msg': "提交成功", 'content': True}
except Exception as e:
# print("Exception:", e)
raise_logger("add_auto_robot_config Exception",
"game_publish_lottery", "info")
session.rollback()
return {
'e': "add_auto_robot_config Exception",
'content': False
}
return {'content': False}
def dice_sold_out_new(self, dice_id):
change_type_31 = '31' # 扣款
change_type_32 = '32' # 返还
change_type_33 = '33' # 中奖
reward_quantity = decimal.Decimal(0)
with MysqlTools().session_scope() as session:
account_service = AccountService()
dice_info = session.query(DiceParticipateInModel). \
filter(DiceParticipateInModel._id == dice_id).first()
if dice_info is None:
self.return_error(40021)
ec = TokenNodeConfModel.get_eos_node_script(script_unit=_THREE_S)
latest_eos_block_info = ec.http_get_latest_block()
# print('latest_eos_block_info=-=-=', latest_eos_block_info)
dice_info.block_no = latest_eos_block_info.get('block_num', None)
dice_info.block_timestamp = latest_eos_block_info.get(
'timestamp', None)
dice_info.block_hash = latest_eos_block_info.get('id', None)
if dice_info.block_no is None or \
dice_info.block_timestamp is None or \
dice_info.block_hash is None:
self.return_error(40024)
else:
dice_result = -1
banker_dice = int(dice_info.block_hash, 16) % 3 # 0石头 1剪刀 2布
user_dice = dice_info.user_dice # 0石头 1剪刀 2布
if banker_dice == user_dice:
dice_result = 1 # 0用户胜 1平局 2庄家胜 -1未知
else:
if banker_dice == 0 and user_dice == 1:
dice_result = 2
elif banker_dice == 0 and user_dice == 2:
dice_result = 0
elif banker_dice == 1 and user_dice == 0:
dice_result = 0
elif banker_dice == 1 and user_dice == 2:
dice_result = 2
elif banker_dice == 2 and user_dice == 0:
dice_result = 2
elif banker_dice == 2 and user_dice == 1:
dice_result = 0
dice_info.banker_dice = banker_dice
dice_info.dice_result = dice_result
# session.flush()
if dice_result in [0, 1]:
change_type = change_type_32
dice_config = session.query(DiceConfigModel). \
filter(DiceConfigModel.support_token_id == dice_info.bet_token).first()
if dice_config is None:
return self.return_error(40022)
if dice_result == 0:
change_type = change_type_33
# 用户获胜 中奖金额为投注金额+奖励金额(投注金额=奖励金额) 扣除手续费
reward_quantity = (
dice_info.reward_quantity + dice_info.bet_number
) * (100 - dice_config.handling_fee) / 100
dice_info.reward_quantity = reward_quantity
elif dice_result == 1:
change_type = change_type_32
# 平局 中奖金额为投注金额
reward_quantity = dice_info.bet_number
result = account_service.do_win(
session, dice_info.user_id, dice_info.reward_token,
reward_quantity, 'dice_win' + str(dice_info._id),
dice_info.user_dice, dice_info.dice_serial,
change_type)
if isinstance(result, int) is False:
raise_logger(
"dice分钱失败" + "user:"******"game_publish_lottery", "info")
session.rollback()
return False
if result != 0:
raise_logger(
"dice分钱失败" + "user:"******"game_publish_lottery", "info")
session.rollback()
return False
# ret_info = dice_info
# print(ret_info)
session.commit()
session.refresh(dice_info)
# session.expunge(dice_info)
response = {
'dice_result': dice_info.dice_result,
'banker_dice': dice_info.banker_dice,
'user_dice': dice_info.user_dice,
# 'dice_timestamp': timestamp_to_str(dice_info.dice_timestamp, format_style="%Y-%m-%d %H:%M:%S"),
'dice_id': str(dice_info._id),
'dice_serial': dice_info.dice_serial,
'reward_token': self.get_coin_name(dice_info.reward_token),
'reward_quantity': decimal_to_str(reward_quantity, 6)
# 'reward_quantity': decimal_to_str(
# str((dice_info.bet_number + dice_info.bet_number) * decimal.Decimal(0.99)), 6)
}
if dice_info.reward_token == int(_COIN_ID_USDT):
response['reward_quantity'] = decimal_to_str(reward_quantity, 4)
return response
def bet_in(self, dic):
change_type_41 = '41' # 即时开中奖
change_type_42 = '42' # 即时开投注
id = dic.get("game_instance_id", "") # 项目id
user_id = dic.get("user_id", "") # 用户id
user_channel_id = dic.get("user_channel_id", "") # 用户下注渠道id
conin_id = dic.get("coin_id", "") # 投入币种id
bet_amount = dic.get("bet_amount", "") # 投注数量
bet_start = dic.get("bet_start", 0)
bet_end = dic.get("bet_end", 0)
faker = True
# merge_id = dic.get("merge_id", -1) # 合并投注id
# transaction_password = dic.get("transaction_password", "") # 交易密码
with MysqlTools().session_scope() as session:
# 查询项目
model = session.query(InstantGameInstanceModel).filter(
InstantGameInstanceModel._id == id).first()
template = session.query(InstantGameTemplateModel). \
order_by(InstantGameTemplateModel._id.desc()).first()
if model is None:
return self.return_error(60001)
if model.status == 1:
return self.return_error(60002)
if model.status == 2:
return self.return_error(60003)
if model.status == 0:
can_bet = model.need - model.bet_number
if can_bet <= 0:
return self.return_error(60002)
if int(bet_amount) > can_bet:
return self.return_error(60004)
if model.support_token >= 0 and int(
conin_id) != model.support_token and int(conin_id) != int(
_COIN_ID_EXP):
return self.return_error(60008)
if int(bet_amount) > model.need * (model.max_bet_ratio / 100):
return self.return_error(40025)
# 查询币价 币种实际需要金额
exchange_rate = get_exchange_rate(int(conin_id))
# (投注数量 * 投注单位) / 投注币种兑换usdt比例
bet_money = (int(bet_amount) *
model.bet_unit) / exchange_rate['price']
# 体验金相关逻辑
if int(conin_id) == int(_COIN_ID_EXP):
# 检查本次投注体验金使用数量 (允许范围: 1~10)
if int(bet_amount) < 1 or int(bet_amount) > 10:
self.return_error(60015)
# 体验金使用额度
exp = int(model.experience / 100 * model.need)
# 检查项目体验金占比剩余额度以及个人当天最大体验金使用额度(每天最多用10个)
limit = self.check_instance_exp_limit(session, user_id,
model.game_serial)
# instance_limit = limit['instance_limit']
user_limit = limit['user_limit']
total_pay_number = limit['total_pay_number']
if user_limit > 10 - int(bet_amount):
self.return_error(60017)
# if instance_limit >= exp:
# self.return_error(60016)
if total_pay_number >= int(
model.need) * model.reward_quantity * (
(100 + template.exceeded_ratio) / 100):
model.full_load_time = datetime.datetime.utcnow()
faker = False
else:
limit = self.check_instance_exp_limit(session, user_id,
model.game_serial)
total_pay_number = limit['total_pay_number']
raise_logger("总下注金额" + "USDT:" + str(total_pay_number),
"game_publish_lottery", "info")
if total_pay_number >= int(
model.need) * model.reward_quantity * (
(100 + template.exceeded_ratio) / 100):
model.full_load_time = datetime.datetime.utcnow()
faker = False
# 查询用户资产
account_service = AccountService()
user_info = account_service.get_inner_user_account_by_token(
session, user_id, conin_id)
if isinstance(user_info, int):
if user_info == 20001:
return self.return_error(20001)
balance = get_decimal(user_info.get("balance"),
digits=8,
decimal_type="down")
# 账户余额 < 需要下注金额
if balance < bet_money:
return self.return_error(60005)
# 获取下注编号
numbers = []
user_lottery_num_list = []
i = int(bet_amount)
# start_num = random.randint(1, model.need 0- int(bet_amount))
bet_start = int(bet_start)
bet_end = int(bet_end)
user_lottery_num_list.append(bet_start)
user_lottery_num_list.append(bet_end)
while i > 0:
numbers.append(bet_start)
bet_start += 1
i -= 1
if isinstance(numbers, list):
nick_name = account_service.get_inner_user_account_info(
session, user_id).get("nick_name")
# 添加参与记录
participate_in_model = ParticipateInModel(
game_instance_id=0,
template_id=model.template_id,
game_serial=model.game_serial,
game_title=model.game_title,
release_type=model.release_type,
bet_token=model.bet_token,
bet_unit=model.bet_unit,
user_id=user_id,
nick_name=nick_name,
channel=user_channel_id,
bet_number=int(bet_amount),
pay_token=int(conin_id),
pay_number=get_decimal(bet_money,
digits=8,
decimal_type="down"),
award_numbers=json.dumps(numbers),
user_type=0,
merge_id=-1)
session.add(participate_in_model)
session.flush()
# raise_logger("add participate_in_model", "game_bet_in", "info")
# 提交扣款申请
result = account_service.do_bet(
session, user_id, conin_id,
get_decimal(bet_money, digits=8, decimal_type="down"),
str(participate_in_model._id), int(bet_amount),
model.game_serial, user_channel_id, change_type_42)
# raise_logger("do_bet success", "game_bet_in", "info")
if isinstance(result, int):
if result == 0:
instant_game_service = InstantGameModelService()
# print('user_lottery_num_list-=-=', user_lottery_num_list)
# print('model.need-=-=', model.need)
# print('faker-=-=', faker)
lottery_result = WalletEosService().\
lottery_instant_adduce(get_timestamp(), user_lottery_num_list, model.need, faker)
# print('lottery_result-=-=', lottery_result)
if not any(lottery_result):
raise_logger("lottery_result empty", "game_bet_in",
"info")
session.rollback()
return self.return_error(40026)
# 开奖
hash_numbers = lottery_result['block_hash']
raise_logger(
"项目:" + str(id) + " 中奖区块号:" + str(hash_numbers),
"game_publish_lottery", "info")
if hash_numbers == "":
raise_logger("开奖异常:80001", "game_publish_lottery",
"info")
return False
# prize_number = int(hash_numbers, 16) % model.need + 1
prize_number = lottery_result['lottery_num']
raise_logger(
"项目:" + str(id) + " 中奖号码:" + str(prize_number),
"game_publish_lottery", "info")
participate_in_model.win_number = prize_number
participate_in_model.block_no = lottery_result[
'block_num']
participate_in_model.bet_hash = hash_numbers
participate_in_model.received_time = lottery_result[
'timestamp']
# 中奖
is_win = False
if prize_number in numbers:
is_win = True
participate_in_model.result = 1
model.lottery_time = datetime.datetime.utcnow()
instant_game_service.automatic_release(
session, model.template_id)
do_win = account_service.do_win(
session, user_id, model.reward_token,
model.reward_quantity,
str(participate_in_model._id), int(bet_amount),
model.game_serial, change_type_41)
if isinstance(do_win, int) is False:
raise_logger("分钱失败" + "user:"******"game_publish_lottery", "info")
session.rollback()
return False
if do_win != 0:
raise_logger("分钱失败" + "user:"******"game_publish_lottery", "info")
session.rollback()
return False
session.commit()
return {
'is_win': is_win,
'prize_number': prize_number,
'part_in_id': participate_in_model._id
}
else:
session.rollback()
return self.return_error(60009)
else:
session.rollback()
return self.return_error(60010)
else:
session.rollback()
return self.return_error(60007)
def test_log(self):
raise_logger("this is test", log_name='wallet', lv="info")
raise_logger("this is test error ", log_name='wallet', lv="error")
def bet_in(self, dic):
id = dic.get("game_instance_id", "") # 项目id
user_id = dic.get("user_id", "") # 用户id
user_channel_id = dic.get("user_channel_id", "") # 用户下注渠道id
conin_id = dic.get("conin_id", "") # 投入币种id
bet_amount = dic.get("bet_amount", "") # 投注数量
merge_id = dic.get("merge_id", -1) # 合并投注id
# transaction_password = dic.get("transaction_password", "") # 交易密码
with MysqlTools().session_scope() as session:
# 查询项目
model = session.query(GameDigitalInstanceModel).filter(
GameDigitalInstanceModel._id == id).with_for_update().first()
if model is None:
return self.return_error(60001)
if model.status == 1:
return self.return_error(60002)
if model.status == 2:
return self.return_error(60003)
if model.status == 0:
can_bet = model.need - model.bet_number
if can_bet <= 0:
return self.return_error(60002)
if int(bet_amount) > can_bet:
return self.return_error(60004)
if model.support_token >= 0 and int(
conin_id) != model.support_token and int(conin_id) != int(
_COIN_ID_EXP):
return self.return_error(60008)
# 查询币价 币种实际需要金额
exchange_rate = get_exchange_rate(int(conin_id))
# (投注数量 * 投注单位) / 投注币种兑换usdt比例
bet_money = (int(bet_amount) *
model.bet_unit) / exchange_rate['price']
# 体验金相关逻辑
if int(conin_id) == int(_COIN_ID_EXP):
# 检查本次投注体验金使用数量 (允许范围: 1~10)
if int(bet_amount) < 1 or int(bet_amount) > 10:
self.return_error(60015)
# 体验金使用额度
exp = int(model.experience / 100 * model.need)
# 检查项目体验金占比剩余额度以及个人当天最大体验金使用额度(每天最多用10个)
limit = self.check_instance_exp_limit(session, user_id, id)
instance_limit = limit['instance_limit']
user_limit = limit['user_limit']
if user_limit > 10 - int(bet_amount):
self.return_error(60017)
if instance_limit >= exp:
self.return_error(60016)
# 查询用户资产
account_service = AccountService()
user_info = account_service.get_inner_user_account_by_token(
session, user_id, conin_id)
if isinstance(user_info, int):
if user_info == 20001:
return self.return_error(20001)
balance = get_decimal(user_info.get("balance"),
digits=8,
decimal_type="down")
# 账户余额 < 需要下注金额
if balance < bet_money:
return self.return_error(60005)
# 验证交易密码
# if account_service.check_pay_password(user_id, transaction_password) is False:
# return self.return_error(35024)
# raise_logger("begin", "game_bet_in", "info")
# 获取下注编号
game_numbers = session.query(GameNumbersSetModel).filter(
GameNumbersSetModel.game_serial ==
model.game_serial).with_for_update().all()
numbers = []
for num in game_numbers:
numbers.append(num.number)
numbers = random.sample(numbers, int(bet_amount))
# raise_logger("get game_numbers", "game_bet_in", "info")
if isinstance(numbers, list):
nick_name = account_service.get_inner_user_account_info(
session, user_id).get("nick_name")
try:
# 添加参与记录
participate_in_model = ParticipateInModel(
game_instance_id=model._id,
template_id=model.template_id,
game_serial=model.game_serial,
game_title=model.game_title,
release_type=model.release_type,
bet_token=model.bet_token,
bet_unit=model.bet_unit,
user_id=user_id,
nick_name=nick_name,
channel=user_channel_id,
bet_number=int(bet_amount),
pay_token=int(conin_id),
pay_number=get_decimal(bet_money,
digits=8,
decimal_type="down"),
award_numbers=json.dumps(numbers),
user_type=0,
merge_id=merge_id)
session.add(participate_in_model)
session.flush()
# raise_logger("add participate_in_model", "game_bet_in", "info")
# 提交扣款申请
result = account_service.do_bet(
session, user_id, conin_id,
get_decimal(bet_money, digits=8, decimal_type="down"),
str(participate_in_model._id), int(bet_amount),
model.game_serial, user_channel_id)
# raise_logger("do_bet success", "game_bet_in", "info")
if isinstance(result, int):
if result == 0:
# 修改项目状态
game_service = GameService()
# raise_logger("modifyDigitalInstance begin", "game_bet_in", "info")
if game_service.modifyDigitalInstance(
model, {
"game_id": id,
"add_bet_number": int(bet_amount),
"full_load_time":
participate_in_model.created_at,
"add_people": 1
}) is False:
session.rollback()
raise_logger("modifyDigitalInstance err",
"game_bet_in", "info")
return self.return_error(80005)
# raise_logger("modifyDigitalInstance succ", "game_bet_in", "info")
try:
created_at_str = str(
participate_in_model.created_at)
update_at_str = str(
participate_in_model.update_at)
deleted_at_str = str(
participate_in_model.deleted_at)
deleted_str = str(participate_in_model.deleted)
if BlockChainInfoService(
).insert_block_chain_info(
user_id,
participate_in_model.game_instance_id,
1,
{
"id":
participate_in_model._id,
"created_at":
created_at_str[0:19],
"update_at":
update_at_str[0:19],
"deleted_at":
deleted_at_str[0:19],
"deleted":
deleted_str[0:19],
"game_instance_id":
str(participate_in_model.
game_instance_id),
"template_id":
participate_in_model.template_id,
"game_serial":
participate_in_model.game_serial,
"bet_token":
participate_in_model.bet_token,
"user_id":
participate_in_model.user_id,
"nick_name":
participate_in_model.nick_name,
"channel":
participate_in_model.channel,
"pay_token":
participate_in_model.pay_token,
"bet_number":
participate_in_model.bet_number,
"pay_number":
str(participate_in_model.pay_number),
"award_numbers":
participate_in_model.award_numbers,
"user_type":
participate_in_model.user_type,
}):
participate_in_model.chain_status = 1
# raise_logger("insert_block succ", "game_bet_in", "info")
else:
raise_logger("insert_block err",
"game_bet_in", "info")
except Exception as e:
session.rollback()
raise_logger(e, "game_bet_in", "info")
# raise_logger("pri del GameNumbersSetModel", "game_bet_in", "info")
for i in numbers:
# raise_logger("pri del GameNumbersSetModel", "game_bet_in", "info")
# game_number_filters = {"game_serial": model.game_serial, "number": i}
session.query(GameNumbersSetModel). \
filter(GameNumbersSetModel.game_serial == model.game_serial,
GameNumbersSetModel.number == i).delete()
# number_filter.time_stamp = 1
# session.delete(num_filters)
# raise_logger("GameNumbersSetModel delete succ", "game_bet_in", "info")
# # 检测游戏是否售罄需要申请开奖
# instance = session.query(GameDigitalInstanceModel).filter(
# GameDigitalInstanceModel._id == id).first()
if int(model.status) == 1:
add_result = WalletEosService().lottery_adduce(
id, get_timestamp(model.full_load_time))
if not add_result:
raise_logger("lottery_adduce fail",
"game_bet_in", "info")
session.commit()
# raise_logger("commit succ", "game_bet_in", "info")
try:
# # 提交验证是否需要上线新项目
game_service.automatic_release(
session, model.template_id)
except Exception as e:
raise_logger(e, "game_bet_in", "info")
can_merge = False
if int(
bet_amount
) >= model.merge_threshold and merge_id == -1:
can_merge = True
# raise_logger("pri return", "game_bet_in", "info")
return {
'numbers': numbers,
'can_merge': can_merge,
'part_in_id': participate_in_model._id
}
else:
session.rollback()
return self.return_error(60009)
else:
session.rollback()
return self.return_error(60010)
except Exception as e:
raise_logger(e, "game_bet_in", "info")
session.rollback()
return self.return_error(60011)
if isinstance(numbers, int):
session.rollback()
return self.return_error(60012)
else:
session.rollback()
return self.return_error(60007)
def check_game_sold_out_by_eos(self, id, block_no, block_hash, timestamp,
received_time):
with MysqlTools().session_scope() as session:
model = session.query(GameDigitalInstanceModel).filter(
GameDigitalInstanceModel._id == id,
GameDigitalInstanceModel.status ==
1).with_for_update().first()
if model is None:
return False
result_block = {
'block_no': block_no,
'block_hash': block_hash,
'timestamp': timestamp,
'received_time': received_time
}
hash_numbers = result_block["block_hash"]
raise_logger("项目:" + str(id) + " 中奖区块号:" + str(hash_numbers),
"game_publish_lottery", "info")
if hash_numbers == "":
raise_logger("开奖异常:80001", "game_publish_lottery", "info")
return False
prize_number = int(hash_numbers, 16) % model.need + 1
raise_logger("项目:" + str(id) + " 中奖号码:" + str(prize_number),
"game_publish_lottery", "info")
# print("中奖号码", str(prize_number))
participate_in = ParticipateInService()
records = participate_in.search_model(session, id)
# 无人参与
if len(records) <= 0:
raise_logger("无人参与80002", "game_publish_lottery", "info")
return False
user_id = ""
user_pay_token = 0
user_bet_number = 0
user_type = 0
merge_id = -1
part_in_id = -1
for item in records:
numbers = json.loads(item.award_numbers)
if prize_number in numbers:
part_in_id = item._id
user_id = item.user_id
user_pay_token = item.pay_token
user_bet_number = item.bet_number
user_type = item.user_type
merge_id = item.merge_id
break
# 无人中奖
if user_id == "":
raise_logger("无人中奖80003", "game_publish_lottery", "info")
return False
raise_logger("中奖user_id:" + str(user_id), "game_publish_lottery",
"info")
win_record = session.query(GameDigitalInstanceModel).filter(
WinningRecordModel.game_instance_id == id).first()
# game_instance_id已经存在开奖纪录
if win_record:
raise_logger(str(id) + "开奖纪录", "game_publish_lottery", "info")
return False
# 修改game实体添加开奖时间 和币价信息
game_service = GameService()
lottery_time_str = str(get_utc_now())
lottery_time = lottery_time_str[0:19]
if game_service.modifyDigitalInstance(model, {
"game_id": id,
"lottery_time": lottery_time
}) is False:
raise_logger("开奖纪录modifyDigitalInstance False",
"game_publish_lottery", "info")
return False
raise_logger("开奖纪录modifyDigitalInstance 修改成功",
"game_publish_lottery", "info")
try:
# 添加开奖纪录
winning_record_model = WinningRecordModel(
created_at=lottery_time,
game_instance_id=id,
game_serial=model.game_serial,
bet_serial=str(prize_number),
bet_hash=hash_numbers,
reward_token=model.reward_token,
reward_quantity=model.reward_quantity,
user_id=user_id,
bet_token=user_pay_token,
bet_number=user_bet_number,
user_type=user_type,
block_no=result_block['block_no'],
timestamp=result_block['timestamp'],
received_time=result_block['received_time'],
participation=model.participation,
block_type="0",
merge_id=merge_id)
session.add(winning_record_model)
session.flush()
raise_logger("添加开奖纪录", "game_publish_lottery", "info")
# 真实用户 添加 中奖金额
if user_type == 0:
account_service = AccountService()
# 合买逻辑
if merge_id != -1:
raise_logger("合买逻辑", "game_publish_lottery", "info")
total_bet = session.query(func.sum(ParticipateInModel.bet_number).label('total')). \
filter(ParticipateInModel.merge_id == merge_id).first()
win_users = session.query(ParticipateInModel). \
filter(ParticipateInModel.merge_id == merge_id).all()
for win_user in win_users:
reward_quantity = win_user.bet_number / int(float(total_bet.total)) * model.reward_quantity \
* (1 - float(model.handling_fee) / 100)
result = account_service.do_win_new_session(
win_user.user_id, model.reward_token,
decimal.Decimal(reward_quantity),
str(part_in_id), win_user.bet_number,
win_user.game_serial)
if isinstance(result, int) is False:
raise_logger(
"分钱失败" + "user:"******"game_publish_lottery", "info")
session.rollback()
return False
if result != 0:
raise_logger(
"分钱失败" + "user:"******"game_publish_lottery", "info")
session.rollback()
return False
else:
raise_logger("非合买逻辑", "game_publish_lottery", "info")
# 实际奖励金额 = 奖励金额 * (1-手续费%)
reward_quantity = model.reward_quantity * (
1 - model.handling_fee / 100)
result = account_service.do_win(
session, user_id, model.reward_token,
reward_quantity, str(part_in_id), user_bet_number,
model.game_serial)
if isinstance(result, int) is False:
raise_logger("分钱失败" + "user:"******"game_publish_lottery", "info")
session.rollback()
return False
if result != 0:
raise_logger("分钱失败" + "user:"******"game_publish_lottery", "info")
session.rollback()
return False
raise_logger("分钱成功", "game_publish_lottery", "info")
try:
# 添加上链数据
lottery_time_str = str(model.lottery_time)
release_time_str = str(model.release_time)
full_load_time_str = str(model.full_load_time)
nick_name = session.query(
ParticipateInModel.nick_name).filter(
ParticipateInModel.user_id == user_id).first()
if BlockChainInfoService().insert_block_chain_info(
"", id, 0,
{
"id": winning_record_model._id,
"game_instance_id":
winning_record_model.game_instance_id,
"game_serial": winning_record_model.game_serial,
"bet_serial": winning_record_model.bet_serial,
"bet_hash": winning_record_model.bet_hash,
"reward_token": winning_record_model.reward_token,
"reward_quantity":
winning_record_model.reward_quantity,
"user_id": winning_record_model.user_id,
"bet_token": winning_record_model.bet_token,
"bet_number": winning_record_model.bet_number,
"user_type": winning_record_model.user_type,
"block_no": winning_record_model.block_no,
"timestamp": winning_record_model.timestamp,
"received_time":
winning_record_model.received_time,
"block_type": winning_record_model.block_type,
"participation":
winning_record_model.participation,
"lottery_time": lottery_time_str[0:19],
"game_describe": model.game_describe,
"nick_name": nick_name,
"need": model.need,
"release_time": release_time_str[0:19],
"full_load_time": full_load_time_str[0:19],
}):
winning_record_model.chain_status = 1
except Exception as e:
raise_logger("开奖insert_block_chain_info Exception",
"game_publish_lottery", "info")
session.commit()
return True
except Exception as e:
raise_logger(e.__str__(), "game_publish_lottery", "info")
session.rollback()
return False
import sys
from pathlib import Path
pro_name = "TokenPark"
current_path = str(Path(__file__).resolve())
import_index = current_path.rfind(pro_name)
import_path = current_path[:import_index + len(pro_name)]
path_flag = True if not import_path in sys.path else False
if path_flag:
sys.path.append(import_path)
from utils.log import raise_logger
if __name__ == "__main__":
raise_logger("info123", "game_bet_in", "info")
raise_logger("error 123", "game_bet_in", "error")
def robot_bet_in(self, dic):
id = dic.get("game_instance_id", "") # 项目id
user_id = dic.get("user_id", "") # 用户id
conin_id = dic.get("conin_id", 0) # 投入币种id
bet_amount = dic.get("bet_amount", 0) # 投注数量
time_stamp = dic.get("time_stamp", 0) # 纪录时间戳
with MysqlTools().session_scope() as session:
# 查询项目
model = session.query(GameDigitalInstanceModel).filter(
GameDigitalInstanceModel._id == id).with_for_update().first()
if model is None:
raise_logger("机器人下注失败60001", "game_bet_in", "info")
return 60001
if model.status == 1:
raise_logger("机器人下注失败60002", "game_bet_in", "info")
return 60002
if model.status == 2:
raise_logger("机器人下注失败60003", "game_bet_in", "info")
return 60003
if model.status == 0:
can_bet = model.need - model.bet_number
if can_bet <= 0:
raise_logger("机器人下注失败60002", "game_bet_in", "info")
return 60005
if int(bet_amount) > can_bet:
raise_logger("机器人下注失败60004", "game_bet_in", "info")
return 60004
# 查询币价 币种实际需要金额
exchange_rate = get_exchange_rate(int(conin_id))
# (投注数量 * 投注单位) / 投注币种兑换usdt比例
bet_money = (int(bet_amount) *
model.bet_unit) / exchange_rate['price']
game_numbers = session.query(GameNumbersSetModel).filter(
GameNumbersSetModel.game_serial ==
model.game_serial).with_for_update().all()
numbers = []
for num in game_numbers:
numbers.append(num.number)
try:
numbers = random.sample(numbers, int(bet_amount))
except Exception as e:
raise_logger("机器人下注失败 没有numbers", "game_bet_in", "info")
return False
if isinstance(numbers, list) and len(numbers) > 0:
# try:
# 修改机器人账户状态
user = session.query(RobotAccountModel).filter(
RobotAccountModel.user_id ==
user_id).with_for_update().first()
if user is None:
raise_logger("机器人下注失败70002", "game_bet_in", "info")
return 70002
user.status = 0
# 添加投注纪录
participate_in_model = ParticipateInModel(
game_instance_id=model._id,
template_id=model.template_id,
game_serial=model.game_serial,
game_title=model.game_title,
release_type=model.release_type,
bet_unit=model.bet_unit,
bet_token=model.bet_token,
user_id=user_id,
nick_name=user.nick_name,
channel="0",
bet_number=int(bet_amount),
pay_token=int(conin_id),
pay_number=get_decimal(bet_money),
award_numbers=json.dumps(numbers),
user_type=1)
session.add(participate_in_model)
# 修改项目信息
game_service = GameService()
if game_service.modifyDigitalInstance(
model, {
"game_id": id,
"add_bet_number": int(bet_amount),
"full_load_time": participate_in_model.created_at,
"add_people": 1
}) is False:
session.rollback()
raise_logger("机器人下注失败80005", "game_bet_in", "info")
return 80005
# 修改机器人配置纪录 下注状态
record = session.query(RobotConfigRecordModel).filter(
RobotConfigRecordModel.game_instance_id == id,
RobotConfigRecordModel.user_id == user_id,
RobotConfigRecordModel.time_stamp ==
time_stamp).with_for_update().first()
if record is None:
raise_logger("机器人下注失败70002", "game_bet_in", "info")
return 70002
record.bet_status = 1
# 查看本期 机器人是否都已下注完成
is_finish = True
robots = session.query(RobotConfigRecordModel).filter(
RobotConfigRecordModel.game_instance_id == id,
RobotConfigRecordModel.time_stamp == time_stamp).all()
for r in robots:
if r.bet_status == 0 or r.bet_status == 2:
is_finish = False
break
if is_finish:
# 修改 游戏机器人配置纪录
q = session.query(RobotGameConfigRecordModel).filter(
RobotGameConfigRecordModel.game_instance_id == id,
RobotGameConfigRecordModel.time_stamp ==
time_stamp).with_for_update().first()
if q is None:
raise_logger("机器人下注失败70003", "game_bet_in", "info")
return 70003
q.status = 2
q.end_of_real_time = datetime.datetime.utcnow().strftime(
'%Y-%m-%d %H:%M:%S')
session.flush()
try:
created_at_str = str(participate_in_model.created_at)
update_at_str = str(participate_in_model.update_at)
deleted_at_str = str(participate_in_model.deleted_at)
deleted_str = str(participate_in_model.deleted)
dic = {
"id": participate_in_model._id,
"created_at": created_at_str[0:19],
"update_at": update_at_str[0:19],
"deleted_at": deleted_at_str[0:19],
"deleted": deleted_str[0:19],
"game_instance_id":
participate_in_model.game_instance_id,
"template_id": participate_in_model.template_id,
"game_serial": participate_in_model.game_serial,
"bet_token": participate_in_model.bet_token,
"user_id": participate_in_model.user_id,
"nick_name": participate_in_model.nick_name,
"channel": participate_in_model.channel,
"pay_token": participate_in_model.pay_token,
"bet_number": participate_in_model.bet_number,
"pay_number": str(participate_in_model.pay_number),
"award_numbers": participate_in_model.award_numbers,
"user_type": participate_in_model.user_type,
}
if BlockChainInfoService().insert_block_chain_info(
user_id, participate_in_model.game_instance_id, 1,
dic):
participate_in_model.chain_status = 1
except Exception as e:
session.rollback()
raise_logger("insert_block_chain_info", "game_bet_in",
"info")
g_service = model.game_serial
for i in numbers:
session.query(GameNumbersSetModel).filter(
GameNumbersSetModel.game_serial == g_service,
GameNumbersSetModel.number == i).delete()
# # 检测游戏是否售罄需要申请开奖
if int(model.status) == 1:
add_result = WalletEosService().lottery_adduce(
id, get_timestamp(model.full_load_time))
if not add_result:
raise_logger("lottery_adduce fail", "game_bet_in",
"info")
session.commit()
try:
# # 提交验证是否需要上线新项目
game_service.automatic_release(session, model.template_id)
except Exception as e:
raise_logger("automatic_release", "game_bet_in", "info")
return True
# except Exception as e:
# session.rollback()
# raise_logger("机器人下注失败60006", "game_bet_in", "info")
# return 60006
return False
