def user_approve_new_token():
"""
" Add token that approved by user. It's used for ERC20 function.
"""
try:
data = request.json
if data is None or \
'token_id' not in data:
return response_error(MESSAGE.INVALID_DATA, CODE.INVALID_DATA)
uid = int(request.headers['Uid'])
token_id = data['token_id']
token = Token.find_token_by_id(token_id)
if token is None or \
token.tid is None or \
token.status == -1:
return response_error(MESSAGE.TOKEN_NOT_FOUND,
CODE.TOKEN_NOT_FOUND)
user = User.find_user_with_id(uid)
if token not in user.tokens:
user.tokens.append(token)
else:
return response_error(MESSAGE.TOKEN_APPROVED_ALREADY,
CODE.TOKEN_APPROVED_ALREADY)
db.session.commit()
return response_ok(user.to_json())
except Exception, ex:
db.session.rollback()
return response_error(ex.message)
def clear_data_before_test(self):
token1 = Token.find_token_by_id(1)
token1.tid = None
token1.status = -1
token2 = Token.find_token_by_id(2)
token2.tid = None
token2.status = -1
# reset users
users = db.session.query(User).filter(User.email=='*****@*****.**').all()
for u in users:
u.email = None
# reset referral code
referral = db.session.query(Referral).filter(Referral.user_id==66).first()
if referral is not None:
db.session.delete(referral)
user = User.find_user_with_id(66)
user.tokens = []
db.session.flush()
db.session.commit()
def test_user_approve_token(self):
self.clear_data_before_test()
with self.client:
Uid = 66
params = {
"token_id": 1
}
response = self.client.post(
'/approve_token',
data=json.dumps(params),
content_type='application/json',
headers={
"Uid": "{}".format(Uid),
"Fcm-Token": "{}".format(123),
"Payload": "{}".format(123),
})
data = json.loads(response.data.decode())
self.assertTrue(data['status'] == 0)
# approve token first
token = Token.find_token_by_id(1)
token.tid = 0
token.status = 1
# call appprove token again
response = self.client.post(
'/approve_token',
data=json.dumps(params),
content_type='application/json',
headers={
"Uid": "{}".format(Uid),
"Fcm-Token": "{}".format(123),
"Payload": "{}".format(123),
})
data = json.loads(response.data.decode())
self.assertTrue(data['status'] == 1)
def add_match():
try:
from_request = request.headers.get('Request-From', 'mobile')
request_size = request.headers.get('Content-length') # string
uid = int(request.headers['Uid'])
token_id = request.args.get('token_id')
file_name = None
saved_path = None
if request.form.get('data') is None:
return response_error(MESSAGE.INVALID_DATA, CODE.INVALID_DATA)
item = json.loads(request.form.get('data'))
if request.files and len(
request.files) > 0 and request.files['image'] is not None:
if int(
request_size
) <= CONST.UPLOAD_MAX_FILE_SIZE and storage_bl.validate_extension(
request.files['image'].filename,
CONST.UPLOAD_ALLOWED_EXTENSIONS):
file_name, saved_path = storage_bl.handle_upload_file(
request.files['image'])
else:
return response_error(MESSAGE.FILE_TOO_LARGE,
CODE.FILE_TOO_LARGE)
if token_id is None:
contract = contract_bl.get_active_smart_contract()
if contract is None:
return response_error(MESSAGE.CONTRACT_EMPTY_VERSION,
CODE.CONTRACT_EMPTY_VERSION)
else:
token = Token.find_token_by_id(token_id)
if token is None:
return response_error(MESSAGE.TOKEN_NOT_FOUND,
CODE.TOKEN_NOT_FOUND)
token_id = token.id
# refresh erc20 contract
contract = contract_bl.get_active_smart_contract(
contract_type=CONST.CONTRACT_TYPE['ERC20'])
if contract is None:
return response_error(MESSAGE.CONTRACT_EMPTY_VERSION,
CODE.CONTRACT_EMPTY_VERSION)
response_json = []
source = None
category = None
if match_bl.is_validate_match_time(item) == False:
return response_error(MESSAGE.MATCH_INVALID_TIME,
CODE.MATCH_INVALID_TIME)
if "source_id" in item:
# TODO: check deleted and approved
source = db.session.query(Source).filter(
Source.id == int(item['source_id'])).first()
elif "source" in item and "name" in item["source"] and "url" in item[
"source"]:
source = db.session.query(Source).filter(
and_(Source.name == item["source"]["name"],
Source.url == item["source"]["url"])).first()
if source is None:
source = Source(name=item["source"]["name"],
url=item["source"]["url"],
created_user_id=uid)
db.session.add(source)
db.session.flush()
else:
if item['public'] == 1:
return response_error(MESSAGE.MATCH_SOURCE_EMPTY,
CODE.MATCH_SOURCE_EMPTY)
if "category_id" in item:
category = db.session.query(Category).filter(
Category.id == int(item['category_id'])).first()
else:
if "category" in item and "name" in item["category"]:
category = db.session.query(Category).filter(
Category.name == item["category"]["name"]).first()
if category is None:
category = Category(name=item["category"]["name"],
created_user_id=uid)
db.session.add(category)
db.session.flush()
image_url_default = CONST.SOURCE_GC_DOMAIN.format(
app.config['GC_STORAGE_BUCKET'],
'{}/{}'.format(app.config.get('GC_STORAGE_FOLDER'),
app.config.get('GC_DEFAULT_FOLDER')),
CONST.IMAGE_NAME_SOURCE_DEFAULT)
if source is not None and source.image_url is not None and source.image_url != '':
image_url_default = source.image_url
match = Match(
homeTeamName=item.get('homeTeamName', ''),
homeTeamCode=item.get('homeTeamCode', ''),
homeTeamFlag=item.get('homeTeamFlag', ''),
awayTeamName=item.get('awayTeamName', ''),
awayTeamCode=item.get('awayTeamCode', ''),
awayTeamFlag=item.get('awayTeamFlag', ''),
name=item['name'],
public=item['public'],
market_fee=int(item.get('market_fee', 0)),
date=item['date'],
reportTime=item['reportTime'],
disputeTime=item['disputeTime'],
created_user_id=uid,
source_id=None if source is None else source.id,
category_id=None if category is None else category.id,
grant_permission=int(item.get('grant_permission', 0)),
creator_wallet_address=item.get('creator_wallet_address'),
outcome_name=item.get('outcome_name'),
event_name=item.get('event_name'),
image_url=image_url_default)
db.session.add(match)
db.session.flush()
# Add default YES outcome
outcome = Outcome(name=CONST.OUTCOME_DEFAULT_NAME,
match_id=match.id,
contract_id=contract.id,
modified_user_id=uid,
created_user_id=uid,
token_id=token_id,
from_request=from_request,
approved=CONST.OUTCOME_STATUS['PENDING'])
db.session.add(outcome)
db.session.flush()
match_json = match.to_json()
match_json['contract'] = contract.to_json()
match_json['source_name'] = None if source is None else source.name
match_json[
'category_name'] = None if category is None else category.name
if source is not None:
source_json = match_bl.handle_source_data(match.source)
match_json["source"] = source_json
if category is not None:
match_json["category"] = category.to_json()
response_json.append(match_json)
# Send mail create market
send_email_create_market.delay(match.id, uid)
db.session.commit()
# Handle upload file to Google Storage
if file_name is not None and saved_path is not None and storage_bl.check_file_exist(
saved_path):
upload_file_google_storage.delay(socket.gethostname(), match.id,
file_name, saved_path)
return response_ok(response_json)
except Exception, ex:
db.session.rollback()
return response_error(ex.message)
def create_market():
"""
" Admin create new markets
" - Based on fixtures.json
" - image file should be stored at /files/temp
"""
try:
fixtures_path = os.path.abspath(os.path.dirname(__file__)) + '/fixtures.json'
data = {}
with open(fixtures_path, 'r') as f:
data = json.load(f)
if 'fixtures' in data:
fixtures = data['fixtures']
for item in fixtures:
contract = contract_bl.get_active_smart_contract()
if contract is None:
return response_error(MESSAGE.CONTRACT_EMPTY_VERSION, CODE.CONTRACT_EMPTY_VERSION)
# check token id
token_id = item['token_id']
if token_id is not None:
token = Token.find_token_by_id(token_id)
if token is None:
return response_error(MESSAGE.TOKEN_NOT_FOUND, CODE.TOKEN_NOT_FOUND)
token_id = token.id
# refresh erc20 contract
contract = contract_bl.get_active_smart_contract(contract_type=CONST.CONTRACT_TYPE['ERC20'])
if contract is None:
return response_error(MESSAGE.CONTRACT_EMPTY_VERSION, CODE.CONTRACT_EMPTY_VERSION)
match = Match(
homeTeamName=item['homeTeamName'],
awayTeamName=item['awayTeamName'],
name=item['name'],
market_fee=int(item.get('market_fee', 0)),
source_id=int(item['source_id']),
category_id=int(item['category_id']),
public=int(item['public']),
date=item['date'],
reportTime=item['reportTime'],
disputeTime=item['disputeTime']
)
db.session.add(match)
db.session.flush()
for o in item['outcomes']:
outcome = Outcome(
name=o.get('name', ''),
match_id=match.id,
contract_id=contract.id,
token_id=token_id,
approved=CONST.OUTCOME_STATUS['APPROVED']
)
db.session.add(outcome)
db.session.flush()
# add Task
task = Task(
task_type=CONST.TASK_TYPE['REAL_BET'],
data=json.dumps(match.to_json()),
action=CONST.TASK_ACTION['CREATE_MARKET'],
status=-1,
contract_address=contract.contract_address,
contract_json=contract.json_name
)
db.session.add(task)
db.session.flush()
# Handle upload file to Google Storage
if item['image'] is not None and len(item['image']) > 0:
upload_file_google_storage.delay(match.id, storage_bl.formalize_filename(os.path.basename(item['image'])), item['image'])
db.session.commit()
return response_ok()
except Exception, ex:
db.session.rollback()
return response_error(ex.message)
def collect_free_bet():
"""
" Collect free-bet in ETH
"""
try:
uid = int(request.headers['Uid'])
chain_id = int(request.headers.get('ChainId', CONST.BLOCKCHAIN_NETWORK['RINKEBY']))
user = User.find_user_with_id(uid)
data = request.json
if data is None:
return response_error(MESSAGE.INVALID_DATA, CODE.INVALID_DATA)
offchain = data.get('offchain', '')
if len(offchain) == 0:
return response_error(MESSAGE.MISSING_OFFCHAIN, CODE.MISSING_OFFCHAIN)
h = []
s = []
offchain = offchain.replace(CONST.CRYPTOSIGN_OFFCHAIN_PREFIX, '')
if 's' in offchain:
offchain = int(offchain.replace('s', ''))
shaker = db.session.query(Shaker).filter(and_(Shaker.id==offchain, Shaker.shaker_id==user.id)).first()
msg = handshake_bl.can_withdraw(handshake=None, shaker=shaker)
if len(msg) != 0:
return response_error(msg, CODE.CANNOT_WITHDRAW)
hs = Handshake.find_handshake_by_id(shaker.handshake_id)
outcome = Outcome.find_outcome_by_id(hs.outcome_id)
# check erc20 token or not
token = Token.find_token_by_id(outcome.token_id)
if token is not None:
return response_error(MESSAGE.HANDSHAKE_CANNOT_WITHDRAW_FREEBET_IN_ERC20, CODE.HANDSHAKE_CANNOT_WITHDRAW_FREEBET_IN_ERC20)
h = db.session.query(Handshake).filter(and_(Handshake.user_id==user.id, Handshake.outcome_id==hs.outcome_id, Handshake.side==shaker.side, Handshake.status==HandshakeStatus['STATUS_INITED'])).all()
s = db.session.query(Shaker).filter(and_(Shaker.shaker_id==user.id, Shaker.side==shaker.side, Shaker.status==HandshakeStatus['STATUS_SHAKER_SHAKED'], Shaker.handshake_id.in_(db.session.query(Handshake.id).filter(Handshake.outcome_id==hs.outcome_id)))).all()
data['hid'] = outcome.hid
data['winner'] = shaker.from_address
else:
offchain = int(offchain.replace('m', ''))
handshake = db.session.query(Handshake).filter(and_(Handshake.id==offchain, Handshake.user_id==user.id)).first()
msg = handshake_bl.can_withdraw(handshake)
if len(msg) != 0:
return response_error(msg, CODE.CANNOT_WITHDRAW)
outcome = Outcome.find_outcome_by_id(handshake.outcome_id)
# check erc20 token or not
token = Token.find_token_by_id(outcome.token_id)
if token is not None:
return response_error(MESSAGE.HANDSHAKE_CANNOT_WITHDRAW_FREEBET_IN_ERC20, CODE.HANDSHAKE_CANNOT_WITHDRAW_FREEBET_IN_ERC20)
h = db.session.query(Handshake).filter(and_(Handshake.user_id==user.id, Handshake.outcome_id==handshake.outcome_id, Handshake.side==handshake.side, Handshake.status==HandshakeStatus['STATUS_INITED'])).all()
s = db.session.query(Shaker).filter(and_(Shaker.shaker_id==user.id, Shaker.side==handshake.side, Shaker.status==HandshakeStatus['STATUS_SHAKER_SHAKED'], Shaker.handshake_id.in_(db.session.query(Handshake.id).filter(Handshake.outcome_id==handshake.outcome_id)))).all()
data['hid'] = outcome.hid
data['winner'] = handshake.from_address
handshakes = []
shakers = []
response = {}
# update status
for hs in h:
hs.status = HandshakeStatus['STATUS_COLLECT_PENDING']
db.session.flush()
handshakes.append(hs)
if hs.id == offchain:
response = hs.to_json()
for sk in s:
sk.status = HandshakeStatus['STATUS_COLLECT_PENDING']
db.session.flush()
shakers.append(sk)
if sk.id == offchain:
response = sk.to_json()
data['uid'] = uid
data['payload'] = user.payload
data['free_bet'] = 1
contract = Contract.find_contract_by_id(outcome.contract_id)
if contract is None:
return response_error(MESSAGE.CONTRACT_INVALID, CODE.CONTRACT_INVALID)
# add task
task = Task(
task_type=CONST.TASK_TYPE['FREE_BET'],
data=json.dumps(data),
action=CONST.TASK_ACTION['COLLECT'],
status=-1,
contract_address=contract.contract_address,
contract_json=contract.json_name
)
db.session.add(task)
db.session.commit()
handshake_bl.update_handshakes_feed(handshakes, shakers)
return response_ok(response)
except Exception, ex:
db.session.rollback()
return response_error(ex.message)
def uninit_free_bet(handshake_id):
"""
" Uninit free-bet in ETH
"""
try:
uid = int(request.headers['Uid'])
chain_id = int(request.headers.get('ChainId', CONST.BLOCKCHAIN_NETWORK['RINKEBY']))
user = User.find_user_with_id(uid)
handshake = db.session.query(Handshake).filter(and_(Handshake.id==handshake_id, Handshake.chain_id==chain_id, Handshake.user_id==uid, Handshake.free_bet==1)).first()
if handshake is not None and \
(handshake.status == CONST.Handshake['STATUS_INITED'] or \
handshake.status == CONST.Handshake['STATUS_MAKER_SHOULD_UNINIT']):
if handshake_bl.can_uninit(handshake) == False:
return response_error(MESSAGE.HANDSHAKE_CANNOT_UNINIT, CODE.HANDSHAKE_CANNOT_UNINIT)
else:
outcome = Outcome.find_outcome_by_id(handshake.outcome_id)
if outcome is None:
return response_error(MESSAGE.OUTCOME_INVALID, CODE.OUTCOME_INVALID)
else:
# check erc20 token or not
token = Token.find_token_by_id(outcome.token_id)
if token is not None:
return response_error(MESSAGE.HANDSHAKE_CANNOT_UNINIT_FREE_BET_IN_ERC20, CODE.HANDSHAKE_CANNOT_UNINIT_FREE_BET_IN_ERC20)
contract = Contract.find_contract_by_id(outcome.contract_id)
if contract is None:
return response_error(MESSAGE.CONTRACT_INVALID, CODE.CONTRACT_INVALID)
handshake.status = CONST.Handshake['STATUS_MAKER_UNINIT_PENDING']
db.session.flush()
data = {
'hid': outcome.hid,
'side': handshake.side,
'odds': handshake.odds,
'maker': handshake.from_address,
'value': handshake.amount,
'offchain': CONST.CRYPTOSIGN_OFFCHAIN_PREFIX + 'm{}'.format(handshake.id),
'uid': uid,
'payload': user.payload,
'free_bet': 1
}
task = Task(
task_type=CONST.TASK_TYPE['FREE_BET'],
data=json.dumps(data, use_decimal=True),
action=CONST.TASK_ACTION['UNINIT'],
status=-1,
contract_address=contract.contract_address,
contract_json=contract.json_name
)
db.session.add(task)
db.session.commit()
update_feed.delay(handshake.id)
return response_ok(handshake.to_json())
else:
return response_error(MESSAGE.HANDSHAKE_NOT_FOUND, CODE.HANDSHAKE_NOT_FOUND)
except Exception, ex:
db.session.rollback()
return response_error(ex.message)
def create_free_bet():
"""
" Create a free-bet in ETH
"""
try:
setting = Setting.find_setting_by_name(CONST.SETTING_TYPE['FREE_BET'])
if setting is not None and setting.status == 0:
return response_error(MESSAGE.FREE_BET_UNABLE, CODE.FREE_BET_UNABLE)
uid = int(request.headers['Uid'])
chain_id = int(request.headers.get('ChainId', CONST.BLOCKCHAIN_NETWORK['RINKEBY']))
user = User.find_user_with_id(uid)
data = request.json
if data is None:
return response_error(MESSAGE.INVALID_DATA, CODE.INVALID_DATA)
redeem = data.get('redeem', '')
match_id = data.get('match_id', -1)
odds = Decimal(data.get('odds', Decimal('2')))
amount = Decimal(CONST.CRYPTOSIGN_FREE_BET_AMOUNT)
side = int(data.get('side', CONST.SIDE_TYPE['SUPPORT']))
from_address = data.get('from_address', '')
# check valid address
if len(from_address) < 40:
return response_error(MESSAGE.INVALID_ADDRESS, CODE.INVALID_ADDRESS)
# check valid redeem or not
r = Redeem.find_redeem_by_code_and_user(redeem, uid)
if r is None:
return response_error(MESSAGE.REDEEM_NOT_FOUND, CODE.REDEEM_NOT_FOUND)
else:
if r.used_user > 0:
return response_error(MESSAGE.REDEEM_INVALID, CODE.REDEEM_INVALID)
r.used_user = uid
db.session.flush()
outcome_id = data.get('outcome_id')
outcome = None
if match_id == -1:
outcome = Outcome.find_outcome_by_id(outcome_id)
if outcome is None:
return response_error(MESSAGE.OUTCOME_INVALID, CODE.OUTCOME_INVALID)
elif outcome.result != -1:
return response_error(MESSAGE.OUTCOME_HAS_RESULT, CODE.OUTCOME_HAS_RESULT)
else:
match = Match.find_match_by_id(match_id)
if match is not None and len(match.outcomes.all()) > 0:
outcome = match.outcomes[0]
else:
return response_error(MESSAGE.MATCH_NOT_FOUND, CODE.MATCH_NOT_FOUND)
# check erc20 token or not
token = Token.find_token_by_id(outcome.token_id)
if token is not None:
return response_error(MESSAGE.HANDSHAKE_CANNOT_CREATE_FREEBET_IN_ERC20, CODE.HANDSHAKE_CANNOT_CREATE_FREEBET_IN_ERC20)
contract = Contract.find_contract_by_id(outcome.contract_id)
if contract is None:
return response_error(MESSAGE.CONTRACT_INVALID, CODE.CONTRACT_INVALID)
match = Match.find_match_by_id(outcome.match_id)
data['hid'] = outcome.hid
data['outcome_name'] = outcome.name
data['match_date'] = match.date
data['match_name'] = match.name
data['uid'] = uid
data['payload'] = user.payload
data['free_bet'] = 1
data['amount'] = CONST.CRYPTOSIGN_FREE_BET_AMOUNT
user.free_bet += 1
task = Task(
task_type=CONST.TASK_TYPE['FREE_BET'],
data=json.dumps(data),
action=CONST.TASK_ACTION['INIT'],
status=-1,
contract_address=contract.contract_address,
contract_json=contract.json_name
)
db.session.add(task)
db.session.commit()
# this is for frontend
handshakes = handshake_bl.find_all_matched_handshakes(side, odds, outcome.id, amount, uid)
response = {}
if len(handshakes) == 0:
response['match'] = 0
else:
response['match'] = 1
return response_ok(response)
except Exception, ex:
db.session.rollback()
return response_error(ex.message)
def init():
"""
" User plays bet in binary event.
"""
try:
from_request = request.headers.get('Request-From', 'mobile')
uid = int(request.headers['Uid'])
chain_id = int(request.headers.get('ChainId', CONST.BLOCKCHAIN_NETWORK['RINKEBY']))
user = User.find_user_with_id(uid)
data = request.json
if data is None:
return response_error(MESSAGE.INVALID_DATA, CODE.INVALID_DATA)
hs_type = data.get('type', -1)
extra_data = data.get('extra_data', '')
description = data.get('description', '')
outcome_id = data.get('outcome_id', -1)
match_id = data.get('match_id', -1)
odds = Decimal(data.get('odds', '2')).quantize(Decimal('.1'), rounding=ROUND_HALF_DOWN)
amount = Decimal(data.get('amount'))
currency = data.get('currency', 'ETH')
side = int(data.get('side', CONST.SIDE_TYPE['SUPPORT']))
chain_id = int(data.get('chain_id', CONST.BLOCKCHAIN_NETWORK['RINKEBY']))
from_address = data.get('from_address', '')
free_bet = data.get('free_bet', 0)
print '-------- DEBUG INIT -------'
print '-------- amount = {}, type = {}, request = {} -------'.format(amount, type(amount), data.get('amount'))
if hs_type != CONST.Handshake['INDUSTRIES_BETTING']:
return response_error(MESSAGE.HANDSHAKE_INVALID_BETTING_TYPE, CODE.HANDSHAKE_INVALID_BETTING_TYPE)
if len(from_address) < 40:
return response_error(MESSAGE.INVALID_ADDRESS, CODE.INVALID_ADDRESS)
# check valid outcome or not
outcome = None
if match_id == -1:
outcome = Outcome.find_outcome_by_id(outcome_id)
else:
match = Match.find_match_by_id(match_id)
if match is not None and len(match.outcomes.all()) > 0:
outcome = match.outcomes[0]
if outcome is None:
return response_error(MESSAGE.OUTCOME_INVALID, CODE.OUTCOME_INVALID)
if outcome.result != CONST.RESULT_TYPE['PENDING']:
return response_error(MESSAGE.OUTCOME_HAS_RESULT, CODE.OUTCOME_HAS_RESULT)
outcome_id = outcome.id
# make sure user cannot call free-bet in ERC20
if free_bet == 1:
token = Token.find_token_by_id(outcome.token_id)
if token is not None:
return response_error(MESSAGE.HANDSHAKE_CANNOT_CREATE_FREEBET_IN_ERC20, CODE.HANDSHAKE_CANNOT_CREATE_FREEBET_IN_ERC20)
if odds <= 1:
return response_error(MESSAGE.INVALID_ODDS, CODE.INVALID_ODDS)
contract = Contract.find_contract_by_id(outcome.contract_id)
if contract is None:
return response_error(MESSAGE.CONTRACT_INVALID, CODE.CONTRACT_INVALID)
# add to history
history = History(
chain_id=chain_id,
description=description,
free_bet=free_bet,
from_address=from_address,
contract_address=contract.contract_address,
contract_json=contract.json_name,
odds=odds,
amount=amount,
currency=currency,
from_request=from_request,
side=side,
user_id=uid,
outcome_id=outcome_id
)
db.session.add(history)
db.session.flush()
# filter all handshakes which able be to match first
handshakes = handshake_bl.find_all_matched_handshakes(side, odds, outcome_id, amount, uid)
arr_hs = []
if len(handshakes) == 0:
handshake = Handshake(
hs_type=hs_type,
extra_data=extra_data,
description=description,
chain_id=chain_id,
user_id=user.id,
outcome_id=outcome_id,
odds=odds,
amount=amount,
currency=currency,
side=side,
remaining_amount=amount,
from_address=from_address,
free_bet=free_bet,
contract_address=contract.contract_address,
contract_json=contract.json_name,
from_request=from_request,
history_id=history.id
)
db.session.add(handshake)
db.session.commit()
update_feed.delay(handshake.id)
# response data
hs_json = handshake.to_json()
hs_json['maker_address'] = handshake.from_address
hs_json['maker_odds'] = handshake.odds
hs_json['hid'] = outcome.hid
hs_json['type'] = 'init'
hs_json['offchain'] = CONST.CRYPTOSIGN_OFFCHAIN_PREFIX + 'm' + str(handshake.id)
arr_hs.append(hs_json)
logfile.debug("Uid -> {}, json --> {}".format(uid, arr_hs))
else:
shaker_amount = amount
hs_feed = []
sk_feed = []
for handshake in handshakes:
if shaker_amount.quantize(Decimal('.00000000000000001'), rounding=ROUND_DOWN) <= 0:
break
handshake.shake_count += 1
handshake_win_value = handshake.remaining_amount*handshake.odds
shaker_win_value = shaker_amount*odds
subtracted_amount_for_shaker = 0
subtracted_amount_for_handshake = 0
if is_equal(handshake_win_value, shaker_win_value):
subtracted_amount_for_shaker = shaker_amount
subtracted_amount_for_handshake = handshake.remaining_amount
elif handshake_win_value >= shaker_win_value:
subtracted_amount_for_shaker = shaker_amount
subtracted_amount_for_handshake = shaker_win_value - subtracted_amount_for_shaker
else:
subtracted_amount_for_handshake = handshake.remaining_amount
subtracted_amount_for_shaker = handshake_win_value - subtracted_amount_for_handshake
handshake.remaining_amount -= subtracted_amount_for_handshake
shaker_amount -= subtracted_amount_for_shaker
db.session.merge(handshake)
o = Outcome.find_outcome_by_id(handshake.outcome_id)
if o is None:
return response_error(MESSAGE.OUTCOME_INVALID, CODE.OUTCOME_INVALID)
c = Contract.find_contract_by_id(o.contract_id)
if c is None:
return response_error(MESSAGE.CONTRACT_INVALID, CODE.CONTRACT_INVALID)
# create shaker
shaker = Shaker(
shaker_id=user.id,
amount=subtracted_amount_for_shaker,
currency=currency,
odds=odds,
side=side,
handshake_id=handshake.id,
from_address=from_address,
chain_id=chain_id,
free_bet=free_bet,
contract_address=c.contract_address,
contract_json=c.json_name,
from_request=from_request,
history_id=history.id
)
db.session.add(shaker)
db.session.flush()
sk_feed.append(shaker)
shaker_json = shaker.to_json()
shaker_json['maker_address'] = handshake.from_address
shaker_json['maker_odds'] = handshake.odds
shaker_json['hid'] = outcome.hid
shaker_json['type'] = 'shake'
shaker_json['offchain'] = CONST.CRYPTOSIGN_OFFCHAIN_PREFIX + 's' + str(shaker.id)
arr_hs.append(shaker_json)
if shaker_amount.quantize(Decimal('.00000000000000001'), rounding=ROUND_DOWN) > Decimal(CONST.CRYPTOSIGN_MINIMUM_MONEY):
handshake = Handshake(
hs_type=hs_type,
extra_data=extra_data,
description=description,
chain_id=chain_id,
user_id=user.id,
outcome_id=outcome_id,
odds=odds,
amount=shaker_amount,
currency=currency,
side=side,
remaining_amount=shaker_amount,
from_address=from_address,
free_bet=free_bet,
contract_address=contract.contract_address,
contract_json=contract.json_name,
from_request=from_request,
history_id=history.id
)
db.session.add(handshake)
db.session.flush()
hs_feed.append(handshake)
hs_json = handshake.to_json()
hs_json['maker_address'] = handshake.from_address
hs_json['maker_odds'] = handshake.odds
hs_json['hid'] = outcome.hid
hs_json['type'] = 'init'
hs_json['offchain'] = CONST.CRYPTOSIGN_OFFCHAIN_PREFIX + 'm' + str(handshake.id)
arr_hs.append(hs_json)
db.session.commit()
logfile.debug("Uid -> {}, json --> {}".format(uid, arr_hs))
handshake_bl.update_handshakes_feed(hs_feed, sk_feed)
# make response
response = {
"handshakes": arr_hs,
"total_bets": handshake_bl.get_total_real_bets()
}
return response_ok(response)
except Exception, ex:
db.session.rollback()
return response_error(ex.message)
def init_data_before_test(self):
# create token
token = Token.find_token_by_id(1)
if token is None:
token = Token(id=1, name="SHURIKEN", symbol="SHURI", decimal=18)
db.session.add(token)
db.session.commit()
# create contract
contract = Contract.find_contract_by_id(1)
if contract is None:
contract = Contract(id=1,
contract_name="contract1",
contract_address="0x123",
json_name="name1")
db.session.add(contract)
db.session.commit()
# create match
match = Match.find_match_by_id(1)
if match is None:
match = Match(id=1)
db.session.add(match)
db.session.commit()
# create user
user = User.find_user_with_id(88)
if user is None:
user = User(id=88)
db.session.add(user)
db.session.commit()
user = User.find_user_with_id(99)
if user is None:
user = User(id=99)
db.session.add(user)
db.session.commit()
user = User.find_user_with_id(100)
if user is None:
user = User(id=100)
db.session.add(user)
db.session.commit()
user = User.find_user_with_id(109)
if user is None:
user = User(id=109)
db.session.add(user)
db.session.commit()
user = User.find_user_with_id(66)
if user is None:
user = User(id=66)
db.session.add(user)
db.session.commit()
# create outcome
outcome = Outcome.find_outcome_by_id(88)
if outcome is None:
outcome = Outcome(id=88,
match_id=1,
hid=88,
contract_id=contract.id)
db.session.add(outcome)
db.session.commit()
else:
outcome.result = -1
outcome.contract_id = contract.id
db.session.commit()
# add redeem
try:
for i in range(1, 3):
chars = string.ascii_uppercase + string.ascii_lowercase
code = ''.join(random.choice(chars) for _ in range(i))
if Redeem.find_redeem_by_code(code) is None:
r = Redeem(code=code)
db.session.add(r)
db.session.commit()
except Exception as ex:
db.session.rollback()
