def get_transaction(card_number: int, date_format: str):
transaction = {
"user_card_number": card_number,
"bonus_miles": randint(300, 3000),
"departure_location": generate_code(),
"arrival_location": generate_code(),
"departure_date": datetime.utcfromtimestamp(randint(1446372000, 1535365267)).strftime(date_format),
}
return transaction
def testGetCode(self):
c = generate_code(alphabet, '^^^^')
self.assertEqual(len(c), 4)
for ch in c:
self.assert_(ch in alphabet)
def testGetCode(self):
c = generate_code(alphabet, '^^^^')
self.assertEqual(len(c), 4)
for ch in c:
self.assert_(ch in alphabet)
def password_reset():
"""Password reset request
"""
if 'username' in session:
return redirect('/')
if request.method == 'POST':
username = request.form['username']
u = User.query.filter_by(username=username).first()
if u == None:
u = User.query.filter_by(email=username).first()
if u == None:
# No user found
flash('No user found under that username/email.', 'error')
return render_template('password_reset_request.html')
# Generate and set code for user
code = generate_code()
u.code = code
db.session.commit()
# Send email with reset link
callback_url = f'{request.base_url}/callback?code={code}&email={u.email}'
send(
to=u.email,
subject='Password Reset was Requested',
body=f'Password request link: {callback_url}',
)
flash('Email requesting password reset successfully sent!', 'info')
return render_template('password_reset_request.html')
else:
return render_template('password_reset_request.html')
def on_post(self, req, resp):
if 'request' not in req.context.keys():
raise RError(16)
request = req.context['request']
if 'username' not in request.keys():
raise RError(20)
if 'password' not in request.keys():
raise RError(20)
user = RAdminUser()
token = utils.generate_code(16)
user.login_by_password(request['username'], request['password'], token)
req.context['result'] = {'token': token, 'username': user.info.username, 'level': user.info.level}
def create(self, sid):
print('Create game room called:', sid)
code = generate_code(5)
nRoom = {
'code': code,
'admin': sid,
'state': 'WAITING_FOR_PLAYERS',
'players': []
}
self.rooms.insert_one(nRoom)
return nRoom
def get_classroom_user_code(classroom_id, user_id, short_code=None):
if short_code is None:
short_code = utils.generate_code()
classroom_user_code_id = insert(
"INSERT INTO classroom_user_code (classroom_id, user_id, short_code, update_time) VALUES(%s, %s, %s, NOW()) ON DUPLICATE KEY UPDATE update_time = NOW()",
[classroom_id, user_id, short_code],
)
return fetchrow(
"SELECT classroom_id, user_id, short_code, update_time FROM classroom_user_code WHERE id = %s",
classroom_user_code_id,
)
def generate_point(room):
print('Generated point thread init.')
while room in active_rooms:
nPoint = generate_code(10)
active_hits.append(nPoint)
cords = {
'x' : random.randint(1,100),
'y' : random.randint(1,100),
}
point = {'hitCode':nPoint, 'cords':cords}
print(f'Generated point', room, '@', point)
socketio.emit('point', dumps(point), room=room, namespace='/game')
socketio.sleep(1)
def main():
logging.info('starting up')
pid = os.fork()
if pid == 0:
signal.signal(signal.SIGTERM, on_term)
pidfile.acquire()
while True:
try:
s = socket.socket(
socket.AF_INET, socket.SOCK_STREAM)
s.connect((config.host, config.port))
s.send(generate_code(config.secret))
s.close()
time.sleep(3)
except socket.error as e:
logging.error(e)
else:
signal.signal(signal.SIGTERM, on_term)
def request_code_service(email: str):
user = mongo.db.users.find_one({'email': email})
if user:
code = generate_code()
cache.set(code, str(user.get('_id')), timeout=1800)
# TODO I would do it would celery, but I don't see the point of doing it in a test task
sent_email_thread = Thread(target=send_email,
args=[
current_app._get_current_object(),
user.get('email'), '*****@*****.**',
'Auth code', code
])
sent_email_thread.start()
return {'status': True, 'message': 'Email sent'}
return None
def testFormat(self):
c = generate_code(alphabet, '^-^-^-^')
for i in (0,2,4,6):
self.assert_(c[i] in alphabet)
for i in (1,3,5):
self.assertEqual(c[i], '-')
def main(screen=None):
if screen is None:
try:
token = curses.wrapper(
main
) # Use curses to handle user input, screen clearing and simplify other display management tools
if token is not None: # If the game has been interrupted and a token to resume was generated, show a message to inform the user
print(
"This game has been interrupted. To resume, copy paste this token:",
token)
except KeyboardInterrupt:
pass
except Exception as e:
if utils.DEBUG:
traceback.print_exc()
else:
print("Oops! An error occured:", e)
return
curses.start_color() # Enable curses' colors
curses.use_default_colors()
curses.curs_set(
0
) # Hide the cursor as we will use a custom way to show the selected color
if len(sys.argv) > 1 and re.match(
"^[A-Za-z0-9+/]*=*$", sys.argv[1]
): # If a (seemingly) valid token was provided, resume this game rather than starting a new one
token = sys.argv[1]
if len(token) % 4 > 0:
token += "=" * (
4 - len(token) % 4
) # Fix Base64 padding by adding equal signs at the end of the token
gamemode, score, games, color_count, max_attempts, code, attempts = utils.decode_token(
token
) # Get all the required information about the pending game from the token
code_length = len(code)
else:
gamemode, code_length, color_count, max_attempts = select_gamemode(
screen)
score, games = 0, 0
code, attempts = None, None
if gamemode == 0:
if code is None:
code = utils.generate_code(
code_length, color_count
) # Generate a random code to "play against the computer"
return singleplayer.main(screen, color_count, max_attempts, score,
games, code, attempts)
elif gamemode == 1:
return online_ranked.main(screen, color_count, max_attempts,
code_length)
elif gamemode == 2:
if code is None:
code = utils.generate_code(
code_length, color_count
) # Generate a random code for the computer to guess
return computer_vs_computer.main(screen, color_count, max_attempts,
score, games, code, attempts)
else:
raise Exception("Unknown gamemode selected: {}".format(gamemode))
def testGetCode2(self):
c = generate_code(alphabet, '^^^^-^^^^')
c2 = generate_code(alphabet, '^^^^-^^^^')
self.assertNotEqual(c,c2)
def testFormat(self):
c = generate_code(alphabet, '^-^-^-^')
for i in (0, 2, 4, 6):
self.assert_(c[i] in alphabet)
for i in (1, 3, 5):
self.assertEqual(c[i], '-')
def add_company(self, **values):
names = self.get_names()
name = generate_code(names, "c%06d")
return self.make_resource(name, Company, **values)
def tick_client(conn, address, data, user_list, scoreboard):
try:
buff = data["inputs"].pop(
0) if data["inputs"] else utils.receive_packet(conn)
if buff:
if data["status"] == 200:
game = user_list[address[0]]["game"]
guess = [0xFFFF] * len(game["code"])
for i in range(len(game["code"])):
guess[i] = int.from_bytes(buff[2 * i:2 * (i + 1)], "big")
perfect, partial = utils.compare_codes(guess, game["code"])
if game["color_count"] == 6 and len(
game["code"]) == 4 and guess == [0, 1, 0, 0]:
utils.send_packet(conn, (418).to_bytes(2, "big"))
utils.send_packet(
conn,
perfect.to_bytes(2, "big") + partial.to_bytes(2, "big"))
if perfect == len(game["code"]):
game["score"] += game["max_attempts"] - len(
game["attempts"])
game["games"] += 1
game["code"] = utils.generate_code(len(game["code"]),
game["color_count"])
game["attempts"] = []
if utils.DEBUG:
print("Client {}:{} won a game on thread #{}.".format(
*address, thread.ident))
else:
game["attempts"].append(guess)
if len(game["attempts"]) >= game["max_attempts"]:
token = utils.encode_token(
game["gamemode"], game["score"], game["games"],
game["color_count"], game["max_attempts"],
game["code"], game["attempts"])
utils.send_packet(conn, token.encode("utf8"))
total_attempts = (game["max_attempts"] +
1) * game["games"] - game["score"]
normalized_score = game["score"]
normalized_score *= game["color_count"]**len(
game["code"]) / 1000
normalized_score /= 1.2**game["max_attempts"] / 10
normalized_score = int(normalized_score)
entry = (address[0], user_list[address[0]]["username"],
game["score"], game["games"], total_attempts,
normalized_score, game["color_count"],
len(game["code"]), game["max_attempts"],
time.time())
for i, other in enumerate(scoreboard):
if other[5] < entry[5] or (
other[5] == entry[5]
and other[3] < entry[3] or
(other[3] == entry[3]
and other[4] > entry[4])):
scoreboard.insert(i, entry)
break
else:
scoreboard.append(entry)
del user_list[address[0]]["game"]
user_list[address[0]]["connected"] = False
data["status"] = 204
utils.send_packet(conn,
data["status"].to_bytes(2, "big"))
if utils.DEBUG:
print("Client {}:{} lost a game on thread #{}.".
format(*address, thread.ident))
elif address[0] in user_list and "connected" in user_list[
address[0]] and user_list[address[0]]["connected"]:
data["status"] = 409
utils.send_packet(conn, data["status"].to_bytes(2, "big"))
conn.close()
if utils.DEBUG:
print(
"Client {}:{} forcefully disconnected from thread #{}."
.format(*address, thread.ident))
return False
elif data["status"] == 204:
token = buff.decode("utf8")
if re.match(r"^SB:\d+ \d+$", token):
page_size, offset = map(int, token[3:].split())
answer_bytes = bytes()
if len(scoreboard) >= offset:
for entry in scoreboard[
offset:min(offset +
page_size, len(scoreboard))]:
username = entry[1].encode("utf8")
if 6 + len(answer_bytes) + len(
username) + 6 > 65535:
break
answer_bytes += (min(len(username), 0xFFFF)
& 0xFFFF).to_bytes(2, "big")
answer_bytes += username
answer_bytes += (min(entry[5], 0xFFFF)
& 0xFFFF).to_bytes(2, "big")
answer_bytes += (min(entry[3], 0xFFFF)
& 0xFFFF).to_bytes(2, "big")
answer_bytes += (min(entry[4], 0xFFFF)
& 0xFFFF).to_bytes(2, "big")
answer_bytes += (min(entry[4], 0xFFFF)
& 0xFFFF).to_bytes(2, "big")
answer_bytes += (min(entry[5], 0xFFFF)
& 0xFFFF).to_bytes(2, "big")
answer_bytes += (min(entry[6], 0xFFFF)
& 0xFFFF).to_bytes(2, "big")
answer_bytes += (
min(int(entry[8] * 1000), 2**64 - 1)
& 2**64 - 1).to_bytes(8, "big")
utils.send_packet(conn, answer_bytes)
else:
gamemode, score, games, color_count, max_attempts, code, attempts = utils.decode_token(
token)
score, games = 0, 0
code = utils.generate_code(len(code), color_count)
user_list[address[0]]["connected"] = True
game = {
"gamemode": gamemode,
"score": score,
"games": games,
"color_count": color_count,
"max_attempts": max_attempts,
"code": code,
"attempts": []
}
user_list[address[0]]["game"] = game
if len(attempts) > max_attempts:
attempts = attempts[:max_attempts]
for attempt in attempts:
attempt_bytes = bytes()
if len(attempt) > len(code):
attempt = attempt[:len(code)]
elif len(attempt) < len(code):
attempt += [0] * (len(code) - len(attempt))
for color in attempt:
attempt_bytes += (min(color, 0xFFFF)
& 0xFFFF).to_bytes(2, "big")
data["inputs"].append(attempt_bytes)
if attempt == code:
break
data["status"] = 200
utils.send_packet(conn, data["status"].to_bytes(2, "big"))
fake_code = [0xFFFF] * len(game["code"])
fake_token = utils.encode_token(game["gamemode"],
game["score"],
game["games"],
game["color_count"],
game["max_attempts"],
fake_code, attempts)
utils.send_packet(conn, fake_token.encode("utf8"))
if utils.DEBUG:
print("Client {}:{} started a new game on thread #{}.".
format(*address, thread.ident))
elif data["status"] == 401 or data["status"] == 403:
username = buff.decode("utf8")
if buff == b"\x36\x39":
for chars in itertools.product(*[
[
b"\x4e", b"\x6e", b"\xc3\xb1", b"\xc5\x84",
b"\xc3\x91", b"\xc5\x83"
],
[
b"\x69", b"\x49", b"\xc3\xae", b"\xc3\xaf",
b"\xc3\xac", b"\xc3\xad", b"\xc4\xaf", b"\xc4\xab",
b"\xc3\x8e", b"\xc3\x8f", b"\xc3\x8c", b"\xc3\x8d",
b"\xc4\xae", b"\xc4\xaa"
],
[
b"\x63", b"\x43", b"\xc3\xa7", b"\xc4\x87",
b"\xc4\x8d", b"\xc3\x87", b"\xc4\x86", b"\xc4\x8c"
],
[
b"\x65", b"\x45", b"\xc3\xa9", b"\xc3\xa8",
b"\xc3\xaa", b"\xc3\xab", b"\xc4\x99", b"\xc4\x97",
b"\xc4\x93", b"\xc3\x89", b"\xc3\x88", b"\xc3\x8a",
b"\xc3\x8b", b"\xc4\x98", b"\xc4\x96", b"\xc4\x92"
]
]):
username = "".join(
map(lambda x: x.decode("utf8"), chars))
for other_address in user_list:
if username == user_list[other_address][
"username"]:
data["status"] = 403
utils.send_packet(
conn, data["status"].to_bytes(2, "big"))
break
else:
break
else:
username = ""
if 3 <= len(username) <= 32 and set(
username) <= USERNAME_CHARACTERS:
for other_address in user_list:
if username == user_list[other_address]["username"]:
data["status"] = 403
utils.send_packet(
conn, data["status"].to_bytes(2, "big"))
break
else:
user_list[address[0]] = {"username": username}
data["status"] = 204
utils.send_packet(conn,
data["status"].to_bytes(2, "big"))
else:
data["status"] = 403
utils.send_packet(conn, data["status"].to_bytes(2, "big"))
elif data["status"] == 300:
if buff.decode("utf8") == "OK":
if address[0] in user_list:
if not "connected" in user_list[address[
0]] or not user_list[address[0]]["connected"]:
if "game" in user_list[address[0]] and user_list[
address[0]]["game"] is not None:
game = user_list[address[0]]["game"]
user_list[address[0]]["connected"] = True
attempts = game["attempts"]
game["attempts"] = []
if len(attempts) > game["max_attempts"]:
attempts = attempts[:game["max_attempts"]]
for attempt in attempts:
attempt_bytes = bytes()
if len(attempt) > len(game["code"]):
attempt = attempt[:len(game["code"])]
elif len(attempt) < len(game["code"]):
attempt += [0] * (len(game["code"]) -
len(attempt))
for color in attempt:
attempt_bytes += (min(color, 0xFFFF)
& 0xFFFF).to_bytes(
2, "big")
data["inputs"].append(attempt_bytes)
if attempt == game["code"]:
break
data["status"] = 200
utils.send_packet(
conn, data["status"].to_bytes(2, "big"))
utils.send_packet(
conn, user_list[address[0]]
["username"].encode("utf8"))
fake_code = [0xFFFF] * len(game["code"])
fake_token = utils.encode_token(
game["gamemode"], game["score"],
game["games"], game["color_count"],
game["max_attempts"], fake_code, attempts)
utils.send_packet(conn,
fake_token.encode("utf8"))
if utils.DEBUG:
print(
"Client {}:{} resumed a game on thread #{}."
.format(*address, thread.ident))
else:
data["status"] = 204
utils.send_packet(
conn, data["status"].to_bytes(2, "big"))
utils.send_packet(
conn, user_list[address[0]]
["username"].encode("utf8"))
else:
data["status"] = 409
utils.send_packet(
conn, data["status"].to_bytes(2, "big"))
conn.close()
if utils.DEBUG:
print(
"Client {}:{} forcefully disconnected from thread #{}."
.format(*address, thread.ident))
return False
else:
data["status"] = 401
utils.send_packet(conn,
data["status"].to_bytes(2, "big"))
return True
except socket.error as e:
if hasattr(e, "skipped_data"):
data = e.skipped_data
if data.decode("utf8").startswith("GET "):
data += conn.recv(65536 - len(e.skipped_data))
if re.match(r"^GET .*? HTTP/\d+(?:\.\d+)*\r\n",
data.decode("utf8")):
conn.send(
base64.b64decode(
"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"
))
conn.close()
if utils.DEBUG:
print("Client {}:{} disconnected from thread #{}.".
format(*address, thread.ident))
return False
if e.errno == errno.EWOULDBLOCK:
return True
elif utils.DEBUG:
traceback.print_exc()
else:
print(e)
except Exception as e:
if utils.DEBUG:
traceback.print_exc()
else:
print(e)
pass
conn.close()
if address[0] in user_list and "connected" in user_list[
address[0]] and user_list[address[0]]["connected"]:
user_list[address[0]]["connected"] = False
if utils.DEBUG:
print("Client {}:{} disconnected from thread #{}.".format(
*address, thread.ident))
return False
def testGetCode2(self):
c = generate_code(alphabet, '^^^^-^^^^')
c2 = generate_code(alphabet, '^^^^-^^^^')
self.assertNotEqual(c, c2)
def add_mission(self, **kw):
names = self.get_names()
name = generate_code(names, 'm%06d')
return self.make_resource(name, Mission, **kw)
def withdraw(bot_username):
if logged_in():
steam_id = request.form.get("steam_id")
trade_token = request.form.get("trade_token")
report_url = request.form.get("report_url")
assets = json.loads(request.form.get("assets"))
additional = json.loads(request.form.get("data"))
current_bot = db_bots.get_username(bot_username)
if not current_bot.get("active", False):
report(service_url="http://%s/trade/withdrawals/%s/report" %
(CONFIG["SERVICE_HOST"], steam_id),
report_url=report_url,
status=6,
error="The bot you are trying to withdraw is offline",
token=CONFIG["ACCESS_TOKEN"],
data={
"bot": bot_username,
"points": additional["points"]
})
return abort(500)
if len(assets) == 0:
report(service_url="http://%s/trade/withdrawals/%s/report" %
(CONFIG["SERVICE_HOST"], steam_id),
report_url=report_url,
status=6,
error="0 Items to withdraw",
token=CONFIG["ACCESS_TOKEN"],
data={
"bot": bot_username,
"points": additional["points"]
})
return abort(500)
if len(assets) > 50:
report(service_url="http://%s/trade/withdrawals/%s/report" %
(CONFIG["SERVICE_HOST"], steam_id),
report_url=report_url,
status=6,
error="50 Items max to withdraw",
token=CONFIG["ACCESS_TOKEN"],
data={
"bot": bot_username,
"points": additional["points"]
})
return abort(500)
current_bot["password"] = simple_decode(CONFIG["CRYPTO_SALT"],
current_bot["password"])
current_bot["shared_secret"] = simple_decode(
CONFIG["CRYPTO_SALT"], current_bot["shared_secret"])
current_bot["identity_secret"] = simple_decode(
CONFIG["CRYPTO_SALT"], current_bot["identity_secret"])
bot_json = {
"username": str(current_bot["username"]),
"password": str(current_bot["password"]),
"shared_secret": str(current_bot["shared_secret"]),
"identity_secret": str(current_bot["identity_secret"]),
"device_id": str(current_bot["device_id"])
}
security_code = generate_code()
additional["security_code"] = security_code
task = withdraw_task.apply_async(args=[
bot_json, steam_id, trade_token, assets, report_url, additional
],
queue="withdraw_task")
return jsonify({
"security_code": security_code,
"bot": current_bot["nickname"],
"task_id": task.id
}), 200
return abort(401)
def main(screen=None,
color_count=None,
max_attempts=None,
score=0,
games=0,
code=None,
attempts=None):
if screen is None:
try:
token = curses.wrapper(
main
) # Use curses to handle user input, screen clearing and simplify other display management tools
if token is not None: # If the game has been interrupted and a token to resume was generated, show a message to inform the user
print(
"This game has been interrupted. To resume, copy paste this token:",
token)
except KeyboardInterrupt:
pass
except Exception as e:
if utils.DEBUG:
traceback.print_exc()
else:
print("Oops! An error occured:", e)
return
curses.start_color() # Enable curses' colors
curses.use_default_colors()
curses.curs_set(
0
) # Hide the cursor as we will use a custom way to show the selected color
code_length = len(code) if code is not None else utils.DEFAULT_CODE_LENGTH
if color_count is None or color_count <= 0:
color_count = utils.DEFAULT_COLOR_COUNT
if max_attempts is None or max_attempts <= 0:
max_attempts = utils.DEFAULT_MAX_ATTEMPTS
curses.init_pair(0, -1, utils.find_nearest_color(0, 0, 0))
curses.init_pair(1, -1, utils.find_nearest_color(1, 1, 1))
for color in range(
2, color_count + 2
): # Initialize all the colors we will need, generating them around the color wheel
# Each color is uniformly spread around the color spectrum, keeping its saturation and value to the max (excludes black and white)
h, s, v = (color - 2) / color_count, 1.0, 1.0
r, g, b = colorsys.hsv_to_rgb(
h, s, v
) # Convert the color from HSV (easier to generate) to RGB (easier to manipulate)
# Because we can't use custom colors in most terminals, we find the closest available one and pair it to the color's id with a white foreground
curses.init_pair(color, -1, utils.find_nearest_color(r, g, b))
global line
while True: # Play an infinite number of games until the user quits the program (with Ctrl+C)
screen.clear()
line = 0
try:
if code is None:
code = utils.generate_code(
code_length, color_count
) # Generate a random code to "play against the computer"
if attempts is None:
attempts = []
game_score = play_game(screen, color_count, max_attempts, code,
attempts)
code, attempts = None, None # Reset the code and the attempts to make the next game independent
except KeyboardInterrupt:
screen.move(line, 0)
screen.clrtoeol(
) # Clear the current line, just in case some text was there
if games > 0:
screen.addstr("Average score: {}\n\r".format(score / games))
screen.refresh()
curses.napms(3000)
token = utils.encode_token(2, score, games, color_count,
max_attempts, code, attempts)
return token
if game_score > 0:
score += game_score # If the computer won this game, we increment his score and the number of (consecutive) games he played
games += 1
if game_score <= 0:
score, games = 0, 0 # If he lost, we reset his score and the number of (consecutive) games
def add_contact(self, **values):
names = self.get_names()
name = generate_code(names, 'c%06d')
return self.make_resource(name, Contact, **values)
def deposit():
if logged_in():
steam_id = request.form.get("steam_id")
trade_token = request.form.get("trade_token")
report_url = request.form.get("report_url")
assets = json.loads(request.form.get("assets"))
additional = json.loads(request.form.get("data"))
active_bots = db_bots.get_all_active()
if len(active_bots) == 0:
report(service_url="http://%s/trade/deposits/%s/report" %
(CONFIG["SERVICE_HOST"], steam_id),
report_url=report_url,
status=6,
error="All bots are offline",
token=CONFIG["ACCESS_TOKEN"],
data={"steam_id": steam_id})
return abort(500)
if len(assets) == 0:
report(service_url="http://%s/trade/deposits/%s/report" %
(CONFIG["SERVICE_HOST"], steam_id),
report_url=report_url,
status=6,
error="0 Items offered",
token=CONFIG["ACCESS_TOKEN"],
data={"steam_id": steam_id})
return abort(500)
if len(assets) > 100:
report(service_url="http://%s/trade/deposits/%s/report" %
(CONFIG["SERVICE_HOST"], steam_id),
report_url=report_url,
status=6,
error="100 Items max to deposit",
token=CONFIG["ACCESS_TOKEN"],
data={"steam_id": steam_id})
return abort(500)
selected_bot = None
biggest_inventory = 0
for bot in active_bots:
try:
inventory_len = int(
redis.get("bot_%s_invnetory_%s_length" %
(str(bot["username"]), 730)))
if inventory_len + len(
assets) + 5 < 950 and inventory_len > biggest_inventory:
selected_bot = bot
biggest_inventory = inventory_len
except:
pass
if not selected_bot:
report(service_url="http://%s/trade/deposits/%s/report" %
(CONFIG["SERVICE_HOST"], steam_id),
report_url=report_url,
status=6,
error="Cannot find proper bot to handle request",
token=CONFIG["ACCESS_TOKEN"],
data={"steam_id": steam_id})
return abort(500)
selected_bot["password"] = simple_decode(CONFIG["CRYPTO_SALT"],
selected_bot["password"])
selected_bot["shared_secret"] = simple_decode(
CONFIG["CRYPTO_SALT"], selected_bot["shared_secret"])
selected_bot["identity_secret"] = simple_decode(
CONFIG["CRYPTO_SALT"], selected_bot["identity_secret"])
bot_json = {
"username": str(selected_bot["username"]),
"password": str(selected_bot["password"]),
"shared_secret": str(selected_bot["shared_secret"]),
"identity_secret": str(selected_bot["identity_secret"]),
"device_id": str(selected_bot["device_id"])
}
security_code = generate_code()
additional["security_code"] = security_code
task = deposit_task.apply_async(args=[
bot_json, steam_id, trade_token, assets, report_url, additional
],
queue="deposit_task")
return jsonify({
"security_code": security_code,
"bot": selected_bot["nickname"],
"task_id": task.id
}), 200
return abort(401)
