async def command_messages_restore_default():
form_data = await get_form_data()
form = CommandMessagesRestoreDefaultForm(form_data)
if request.method == 'POST':
data = form.message_name.data
default_messages = load_message_templates()
if data == 'None':
pass
elif data == 'all':
app.overlord.messages = default_messages
session = database.Session()
if messages_db := session.query(database.Settings).get('messages'):
session.delete(messages_db)
session.commit()
await flash("Command Outputs were reset.")
else:
app.overlord.messages[data] = default_messages[data]
session = database.Session()
if messages_db := session.query(database.Settings).get('messages'):
data_from_db = json.loads(messages_db.value)
new_messages = {}
for message_name in data_from_db:
if not message_name == data:
new_messages[message_name] = default_messages[message_name]
messages_db.value = json.dumps(new_messages)
session.commit()
await flash(f"Command Output '{data}' was reset.")
async def twitch_key_auto_refresher(self):
while True:
if self.tokens_ready and self.twitch_key_expires_at and time.time() + 60 > self.twitch_key_expires_at:
url = 'https://razbi.funcity.org/stocks-chat-minigame/twitch/refresh_token'
querystring = {'access_token': self.twitch_key}
res = requests.get(url, params=querystring)
if res.status_code == 200:
session = database.Session()
twitch_key_db = session.query(database.Settings).get('twitch_key')
if twitch_key_db:
twitch_key_db.value = res.json()['access_token']
expires_at_db = session.query(database.Settings).get('twitch_key_expires_at')
if expires_at_db:
expires_at_db.value = str(int(time.time()) + res.json()['expires_in'])
self.mark_dirty('twitch_key_expires_at')
session.commit()
print("Twitch key refreshed successfully.")
elif res.status_code == 500:
print(
"Tried refreshing the twitch token, but the server is down or smth, please tell Razbi about this. ")
else:
raise ValueError('Unhandled status code when refreshing the twitch key. TELL RAZBI',
res.status_code)
elif self.tokens_ready and self.currency_system == 'stream_elements' and \
self.stream_elements_key_expires_at and time.time() + 60 > self.stream_elements_key_expires_at:
url = 'https://razbi.funcity.org/stocks-chat-minigame/stream_elements/refresh_token'
querystring = {'access_token': self.stream_elements_key}
res = requests.get(url, params=querystring)
if res.status_code == 200:
session = database.Session()
stream_element_key_db = session.query(database.Settings).get('stream_elements_key')
if stream_element_key_db:
stream_element_key_db.value = res.json()['access_token']
expires_at_db = session.query(database.Settings).get('stream_elements_key_expires_at')
if expires_at_db:
expires_at_db.value = str(int(time.time()) + res.json()['expires_in'])
self.mark_dirty('stream_elements_key_expires_at')
session.commit()
print("Stream_elements key refreshed successfully.")
elif res.status_code == 500:
print(
"Tried refreshing the stream_elements token, but the server is down or smth, please tell Razbi about this. ")
else:
raise ValueError('Unhandled status code when refreshing the stream_elements key. TELL RAZBI',
res.status_code)
await asyncio.sleep(60)
def request_warranty(order_item_id):
"""
Запрос решения по гарантии
"""
# парсим входные данные
try:
warranty_request = WarrantyRequest.parse_obj(
request.get_json(force=True))
except BadRequest:
return {"message": "Bad json"}, 400
except ValidationError as e:
return {"message": e.errors()}, 400
with database.Session() as s:
# достаем available_count из базы
order_and_item = (s.query(OrderItem, Item).join(Item).filter(
OrderItem.order_item_uid == order_item_id).one_or_none())
if not order_and_item:
return {"message": "Order not found"}, 404
available_count = order_and_item.Item.available_count
# перенаправляем запрос на warranty
warranty_service_response = circuit_breaker.external_request(
"POST",
f"http://{WARRANTY_SERVICE_URL}{ROOT_PATH}/warranty/{order_item_id}/warranty",
json={
"reason": warranty_request.reason,
"availableCount": available_count
})
if not warranty_service_response.ok:
return {
"message": f"Warranty not found for itemUid '{order_item_id}'"
}, 404
return warranty_service_response.json(), 200
def get_progress(id):
if not utils.validate_id(id):
abort(404)
session = database.Session()
model = session.query(
database.model).filter(database.model.code == id).all()[0]
return jsonify({"progress": model.progress})
def ac14(source, target, machine_number, isotope, skip_calc, **kwargs):
"""Migrate an ac14 database into brahma.
\b
SOURCE: the name of the ac14 database to migrate from
TARGET: the name of the brahma database to migrate to
MACHINE_NUMBER: the number of the machine to migrate. The machine must exist in TARGET!
"""
click.echo('')
with database.Session(**kwargs) as session:
_validate(source, target, session)
_validate_machine_exists(machine_number, target, session)
click.echo(f'Migrating {source} into {target}')
migrator = migration.Ac14Migrator(session, source, target, isotope,
machine_number)
_migrate('run', migrator.migrate_run)
click.echo(' adding cycle_definition:', nl=False)
cycle_definition_id = migrator.add_default_cycle_definition()
click.echo(' done')
_migrate('cycle', migrator.migrate_cycle, cycle_definition_id)
if not skip_calc:
_perform('calculating', 'runs', migrator.calculate_runs)
_perform('calculating', 'targets', migrator.calculate_targets)
click.echo('done')
async def synclol(bot, thing: extradiscord.discord.Message, arguments):
"""Connetti il tuo account di LoL all'account Royal Games!
Sintassi: `{symbol}synclol <nome evocatore>`"""
# Set status to typing
await status_typing(bot, thing)
# Check the command syntax
if len(arguments) < 1:
await display_help(bot, thing, synclol)
return
# Open a new database session
session = database.Session()
# Create a new lol account and connect it to the user
user = session.query(database.Account).filter_by(id=thing.author.id).first()
if user is None:
await answer(bot, thing, "⚠ Fai il login prima di sincronizzare l'account di LoL.")
return
# Check if there are other LoL account registered with the user
user = session.query(database.Account).filter_by(id=thing.author.id).join(database.LoL).all()
if len(user) > 0:
await answer(bot, thing, "⚠ Hai già un account connesso.\n_Se stai cercando di registrare uno smurf, chiedi a Steffo._")
# Get data about the user
summoner_name = " ".join(arguments)
data = await lol.get_summoner_data("euw", summoner_name=summoner_name)
# Create a new database entry for the account
lolaccount = database.LoL(id=data["id"], summoner_name=summoner_name)
lolaccount.parent_id = thing.author.id
session.add(lolaccount)
# Update the newly added user
lolaccount.update_data()
# Send some info to Discord
await d.client.send_message(thing.channel, "Connessione riuscita!", embed=lolaccount.generate_discord_embed())
# Commit the changes to the database
session.commit()
def command(msg):
"""Doodle that Doodle"""
content_type, chat_type, chat_id = telepot.glance(msg)
session = db.Session()
doodle_entry = session.query(db.Doodle).filter_by(chat_id=chat_id).first()
if not doodle_entry:
bot.sendMessage(chat_id, "No doodle saved")
return
chat_entry = session.query(db.Chat).filter_by(chat_id=chat_id).first()
poll = doodle.Doodle(doodle_entry.url)
message = DoodleMessage(poll=poll, chat_entry=chat_entry).get_message()
reply_markup = None
if not poll.is_open:
if show_calendar_link:
ical_url = get_ical_url_from_db(chat_id=chat_id)
if not ical_url:
ical_url = DropBoxUploader(poll).get_url()
doodle_to_db(url=doodle_entry.url, chat_id=doodle_entry.chat_id, ical_url=ical_url)
reply_markup = InlineKeyboardMarkup(inline_keyboard=[
[dict(text='Add to calendar', url=ical_url)]
])
bot.sendMessage(chat_id, message, parse_mode="Markdown", disable_web_page_preview=True, reply_markup=reply_markup)
session.close()
def user_to_db(user_id, chat_id, username=None, first_name=None, last_name=None):
session = db.Session()
entry = db.User(user_id=user_id, username=username, first_name=first_name,
last_name=last_name)
entry.chats.append(db.Chat(chat_id=chat_id))
session.merge(entry)
session.commit()
def init(schema_name, rebuild, seed, **kwargs):
"""Initialize the brahma database schema.
\b
SCHEMA_NAME: the name for the brahma database schema
"""
click.echo('')
with database.Session(**kwargs) as session:
brahma = database.Brahma(schema_name, session)
if brahma.exists:
if rebuild:
click.echo(
f'Warning: The schema {schema_name} already exist => going to drop it',
err=True)
brahma.drop()
else:
click.echo(f'The schema {schema_name} already exist.')
if seed:
seed_default_data(session, schema_name)
return
click.echo(f'Initializing brahma into {schema_name}')
brahma.create()
if seed:
seed_default_data(session, schema_name)
click.echo('done')
def _create_token(username):
session = db.Session()
token = jwt.encode(
{
'username': username,
'exp': datetime.utcnow() + timedelta(minutes=10)
}, SETTINGS['SECRET_KEY'])
refresh_token = str(uuid.uuid4())
query = insert(token_table).values({
'username':
username,
'expired_at':
datetime.utcnow() + timedelta(minutes=60),
'refresh_token':
refresh_token,
}).returning(token_table.c.refresh_token)
try:
inserted_token_data = session.execute(query).fetchone()
except SQLAlchemyError:
session.rollback()
raise
else:
session.commit()
return {
'token': token.decode('UTF-8'),
'refresh_token': inserted_token_data['refresh_token']
}
def sign_up():
data = request.get_json()
session = db.Session()
query = insert(user_table).values({
'username':
data['username'],
'password':
generate_password_hash(data['password'], method='sha256'),
'role':
UserRole.USER,
}).returning(user_table.c.username)
try:
inserted_user_data = session.execute(query).fetchone()
except IntegrityError:
session.rollback()
return jsonify({
'message':
'User with username {} already exists'.format(data['username'])
})
except SQLAlchemyError:
session.rollback()
raise
else:
session.commit()
return jsonify({
'message':
'New user {} is created'.format(inserted_user_data['username'])
})
def request_warranty(order_uid):
"""
Запрос гарантии по заказу
"""
# парсим входные данные
try:
warranty_request = WarrantyRequest.parse_obj(
request.get_json(force=True))
except BadRequest:
return {"message": "Bad json"}, 400
except ValidationError as e:
return {"message": e.errors()}, 400
with database.Session() as s:
# убеждаемся, что заказ есть в базе
order = s.query(Order).filter(
Order.order_uid == order_uid).one_or_none()
if not order:
return {"message": "Order not found"}, 404
# перенаправляем запрос на warehouse
warehouse_service_response = circuit_breaker.external_request(
"POST",
f"http://{WAREHOUSE_SERVICE_URL}{ROOT_PATH}/warehouse/{order.item_uid}/warranty",
json={"reason": warranty_request.reason})
if not warehouse_service_response.ok:
return {"message": "Warranty not found"}, 404
return warehouse_service_response.json(), 200
async def company_names_restore_default_confirm():
session = database.Session()
session.delete(session.query(database.Settings).get('company_names'))
app.overlord.load_names(session)
session.commit()
await flash("Company Names reset successfully.")
return redirect('/customizations/company_names')
async def command_messages():
# form_list = CommandMessagesForm(data={"items": [{"message_name": "thing", 'command_message': "reee"},
# {'message_name': 'thingy2', 'command_message': 'acquire'}]})
form_data = await get_form_data()
messages = []
for key, value in app.overlord.messages.items():
messages.append({'message_name': key, "command_message": value})
form_list = CommandMessagesForm(form_data, data={"items": messages})
test_command_form = TestCommandForm(form_data, data={'user_points': 10000})
if request.method == 'POST':
if form_list.validate():
new_messages = {}
saved_messages = {}
default_messages = load_message_templates()
for res in form_list.items.data:
new_messages[res['message_name']] = res['command_message']
if res['message_name'] in default_messages:
if res['command_message'] != default_messages[res['message_name']]:
print(f"Saved {res['command_message']} because: {res['command_message']} is different than {default_messages[res['message_name']]}")
saved_messages[res['message_name']] = res['command_message']
app.overlord.messages = new_messages
session = database.Session()
# session.query(database.Settings).get('messages').value = json.dumps(app.overlord.messages)
if messages_db := session.query(database.Settings).get('messages'):
messages_db.value = json.dumps(saved_messages)
else:
session.add(database.Settings(key='messages', value=json.dumps(saved_messages)))
session.commit()
await flash("Command Outputs saved successfully.")
async def home():
if app.overlord.api.twitch_key_requires_refreshing:
app.overlord.api.twitch_key_requires_refreshing = False
app.overlord.api.twitch_key_just_refreshed = True
return redirect("https://razbi.funcity.org/stocks-chat-minigame/twitch_login")
if app.overlord.api.stream_elements_key_requires_refreshing:
app.overlord.api.stream_elements_key_requires_refreshing = False
app.overlord.api.stream_elements_key_just_refreshed = True
return redirect("https://razbi.funcity.org/stocks-chat-minigame/streamelements_login")
if not app.overlord.api.tokens_ready:
return redirect(url_for('setup'))
app.overlord.api.console_buffer_done = []
session = database.Session()
most = {
'wealthy_user': session.query(database.User).order_by((database.User.gain-database.User.lost).desc()).first(),
'poorest_user': session.query(database.User).order_by((database.User.gain-database.User.lost)).first(),
'richest_company': session.query(database.Company).order_by(database.Company.stock_price.desc()).first(),
'most_bought_company': session.query(database.Company).order_by(database.Company.stocks_bought.desc()).first(),
'oldest_company': session.query(database.Company).order_by(database.Company.months.desc()).first()
}
return await render_template("home.html", tokens_loaded=app.overlord.api.tokens_ready, started=app.overlord.started,
currency_system=app.overlord.api.currency_system.capitalize(), currency_name=app.overlord.currency_name,
most=most, round=round, int=int)
def game(bot: telegram.Bot, update: telegram.Update, user_data):
logging.info('Get the callback from the keyboard.')
query = update.callback_query
chat_id = query.message.chat_id
user_data['waiting'] = query.data
msg = f'Send a {query.data.lower()}.'
try:
bot.send_message(chat_id=chat_id, text=msg)
except telegram.error.Unauthorized:
logging.info('Get telegram.error.Unathorized')
session = db.Session()
_, game_data = (session.query(db.PlayerGameLink, db.Game).join(
db.Game).filter(db.PlayerGameLink.player_id == chat_id).filter(
db.Game.game_end == None).one_or_none())
game_data.game_cancelled = True
session.commit()
db.Session.remove()
return -1
return 'FIRST'
def update_person(person_id: Any):
"""
обновить человека
"""
try:
person_id = int(person_id)
except Exception:
return response_400("bad person id", {"person_id": person_id})
input_json = request.get_json(force=True)
if not isinstance(input_json, dict):
return response_400("non-json input", {"input": input_json})
try:
person_model = PersonModel.parse_obj(input_json)
except ValidationError as e:
return response_400("bad input json",
{"validation errors": e.errors()})
with database.Session() as s:
person = s.query(Person).get(person_id)
if not person:
return response_404(f"Person with id={person_id} not found")
s.query(Person).filter(Person.id == person_id).update(
person_model.dict())
s.flush()
return s.query(Person).get(person_id).to_json(), 200
def refresh():
data = request.get_json()
session = db.Session()
try:
token = session.execute(
select([token_table]).where(token_table.c.refresh_token ==
data.get('refreshToken'))).fetchone()
except SQLAlchemyError:
session.rollback()
raise
if not token:
return jsonify({'message': 'Token is invalid!'}), 401
username = token['username']
try:
session.execute(
delete(token_table).where(token_table.c.username == username))
except SQLAlchemyError:
session.rollback()
raise
else:
session.commit()
token = _create_token(username)
return jsonify(token)
def crypto_in():
if request.method == "POST":
auth = request.form.get("ipn_auth")
if auth != IPN_AUTH:
abort(401)
address = request.form.get("address")
confirmed = float(request.form.get("confirmed"))
unconfirmed = float(request.form.get("unconfirmed"))
logger.warning("IPN address {} -- confirmed {} -- unconfirmed {}".format(address, confirmed, unconfirmed))
session = database.Session(autocommit=False)
user = CryptoAddress.get_address_user(address=address, session=session)
if user:
logger.warning("IPN for user {} -- address {}".format(user, address))
dep = UserTransactions.get_user_netdeposits(user, session=session)
if confirmed > dep:
UserTransactions.add_transaction(user, confirmed-dep, "deposit", reference="IPN", session=session)
logger.warning("Deposit confirmed! user {} -- address {} -- amount {}".format(user, address, confirmed-dep))
else:
logger.warning("Confirmed is lower than net deposit yet. User {} -- address {} -- conf {} -- dep {} "
.format(user, address, confirmed, dep))
else:
logger.error("Address {} don't match any user.".format(address))
data = {
"address": address,
"confirmed": confirmed,
"unconfirmed": unconfirmed,
"ipn_auth": auth
}
return jsonify(data)
else:
logger.error("Invalid request at IPN url!")
abort(401)
def request_warranty_result(item_uid):
"""
Запрос решения по гарантии
"""
try:
warranty_request = WarrantyRequest.parse_obj(
request.get_json(force=True))
except ValidationError as e:
return {"message": e.errors()}, 400
with database.Session() as s:
warranty = s.query(Warranty).filter(
Warranty.item_uid == item_uid).one_or_none()
if not warranty:
return {"message": "Not found"}, 404
if warranty.status != Status.on:
decision = "REFUSED"
elif warranty_request.availableCount > 0:
decision = "RETURN"
else:
decision = "FIXING"
return {
"warrantyDate": warranty.warranty_date.isoformat(),
"decision": decision
}, 200
def get_ical_url_from_db(chat_id: int) -> str:
session = db.Session()
doodle_entry = session.query(db.Doodle).filter_by(chat_id=chat_id).first()
session.close()
if doodle_entry.ical_url:
return doodle_entry.ical_url
return ""
def loginUser():
username = str(request.json.get('username', ""))
password = str(request.json.get('password', ""))
if (username == "" or password == ""):
resp = jsonify(success=False, message="username or password is empty")
return make_response(resp, 400)
if db.User.query.filter_by(username=username,
password=password).count() != 1:
resp = jsonify(success=False,
message="username not found or password invalid")
return make_response(resp, 404)
token = ''.join(
random.choice(string.ascii_uppercase + string.digits)
for _ in range(TOKEN_LEN))
print "generated token: ", token
timestamp = time.time()
s = db.Session(token, username, timestamp)
db.db_session.add(s)
db.db_session.commit()
u = db.User.query.filter_by(username=s.username).first()
resp = jsonify(success=True, token=token, dropbox=u.dropbox)
return make_response(resp, 201)
def get_changes():
'''
return: [(index, value)]
where index is index of cards array and value is the value to be set
'''
se = db.Session()
changed_cells = se.query(db.Cell).filter(db.Cell.new_state != None).all()
# changed_cells = se.query(db.Cell).filter(db.Cell.state != 'free').all()
if len(changed_cells) == 0:
return []
nums_to_load = []
byte_indexes = []
for i in changed_cells:
start = i.no - i.no % 8
byte_indexes.append(start // 8)
nums_to_load.extend(range(start, start + 8))
nums_to_load = sorted(list(set(nums_to_load)))
byte_indexes = sorted(list(set(byte_indexes)))
needed_cells = se.query(db.Cell).filter(db.Cell.no.in_(nums_to_load)).all()
by_no = {i.no: i for i in needed_cells}
result = []
for byte_index in byte_indexes:
start = byte_index * 8
values = []
for i in range(start, start + 8):
cell = by_no[i]
val = cell.state if cell.new_state is None else cell.new_state
values.append(1 if val == 'on' else 0)
values.reverse()
values = ''.join(map(str, values))
value = int(values, 2)
result.append((byte_index, value))
return result
def shared(self):
db = database.Session()
try:
d = db.query(database.Event).filter_by(action = "sharing", success = True).group_by(database.Event.uid).order_by(database.Event.id.desc()).limit(6).all()
except:
log.error("DB read exception:\n%s" % traceback.format_exc())
return templates.load('shared.html').generate(tracks=d)
def request_warranty(order_uid):
"""
Запрос гарантии по заказу
"""
try:
warranty_request = WarrantyRequest.parse_obj(
request.get_json(force=True))
except ValidationError as e:
return {"message": e.errors()}, 400
if not requests.get(f"http://{WAREHOUSE_SERVICE_URL}/manage/health").ok:
return {"message": "Warehouse sevice unavailable"}, 422
with database.Session() as s:
order = s.query(Order).filter(
Order.order_uid == order_uid).one_or_none()
if not order:
return {"message": "Order not found"}, 404
warehouse_service_response = requests.post(
f"http://{WAREHOUSE_SERVICE_URL}{ROOT_PATH}/warehouse/{order.item_uid}/warranty",
json={"reason": warranty_request.reason})
if not warehouse_service_response.ok:
return {"message": "Warranty not found"}, 404
return warehouse_service_response.json(), 200
def graph(self):
history = {}
db = database.Session()
for i in xrange(1, 24*2): # last 3 days
low = datetime.now() - timedelta(hours = i)
high = low + timedelta(hours = 1)
timestamp = 1000 * time.mktime(high.timetuple())
try:
dayr = db.query(database.Event).add_columns('count(*)', database.Event.action, database.Event.success).group_by('action', 'success').filter(database.Event.start.between(low, high)).all()
n = {}
for daya in dayr:
if daya.action == 'download':
n[daya.action] = [timestamp , int(daya.__dict__['count(*)'])]
elif daya.action == 'remix' or daya.action == 'share':
n["%s%s" % (daya.action, daya.success)] = [timestamp, int(daya.__dict__['count(*)'])]
for k in self.keys:
if not k in history:
history[k] = []
if k in n:
history[k].append(n[k])
else:
history[k].append([timestamp, int(0)])
except:
log.error("DB read exception, rolling back:\n%s" % traceback.format_exc())
db.rollback()
return history
def process_upload_multiple(files, callback_url=None):
id = utils.generate_id()
d = utils.storage_dir_for_id(id)
os.makedirs(d)
file_id = 0
session = database.Session()
m = database.model(id, '')
session.add(m)
for file in files:
fn = file.filename
filewriter = lambda fn: file.save(fn)
filewriter(os.path.join(d, id + "_" + str(file_id) + ".ifc"))
file_id += 1
m.files.append(database.file(id, ''))
session.commit()
session.close()
if DEVELOPMENT:
t = threading.Thread(
target=lambda: worker.process_multiple(id, callback_url))
t.start()
else:
q.enqueue(worker.process_multiple, id, callback_url)
return id
def get(self, uid):
if not uid in r.finished or not os.path.isfile('static/songs/%s.mp3' % uid):
raise tornado.web.HTTPError(404)
else:
db = database.Session()
try:
uploader = db.query(database.Event.ip).filter_by(uid = uid, action = "upload").first()[0]
except:
log.error("DB exception, rolling back:\n%s" % traceback.format_exc())
db.rollback()
uploader = self.request.remote_ip
if uploader != self.request.remote_ip:
log.error("Download attempt on remix %s by IP %s, not uploader %s!" % (uid, self.request.remote_ip, uploader))
raise tornado.web.HTTPError(403)
filename = "%s.mp3" % (r.finished[uid]['tag']['new_title'] if 'new_title' in r.finished[uid]['tag'] else uid)
self.set_header('Content-disposition', 'attachment; filename="%s"' % filename)
self.set_header('Content-type', 'audio/mpeg')
self.set_header('Content-Length', os.stat('static/songs/%s.mp3' % uid)[6])
self.write(open('static/songs/%s.mp3' % uid).read())
self.finish()
try:
db.add(database.Event(uid, "download", success = True, ip = self.request.remote_ip))
db.commit()
except:
log.error("DB exception, rolling back:\n%s" % traceback.format_exc())
db.rollback()
MonitorSocket.update(uid)
def set_progress(id, progress):
session = database.Session()
model = session.query(
database.model).filter(database.model.code == id).all()[0]
model.progress = int(progress)
session.commit()
session.close()
def _parse_file(filename: str):
"""
Add a new file to the database if it doesn't already exist and it is an audio file
:param filename: The path of the file to add
"""
session = database.Session()
file = session.query(database.Track).filter_by(location=filename).one_or_none()
if file is not None:
session.close()
return
try:
with audioread.audio_open(filename) as track:
length = track.duration
valid = True
except:
length = 0.0
valid = False
if valid and length > 0.0:
try:
file = eyed3.load(filename)
artist = file.tag.artist
title = file.tag.title
except:
artist = ''
title = ''
session.add(database.Track(location=filename, artist=artist, title=title, length=length))
session.commit()
session.close()
