def getinstalledinstruments(self):
web.setmime('application/json')
session = db.Session()
inst = [
inst for inst in session.query(db.Datasource)
if inst.sites.count()
]
res = web.as_json(sorted(inst))
session.close()
return res
def delete_sample_user(code):
global APP_SECRET
if (code == APP_SECRET):
session = db.Session()
users = session.query(User).filter_by(login="******").all()
if (len(users) > 0):
for user in users:
session.delete(user)
session.commit()
return redirect(url_for('login'))
def __init__(self) -> None:
self.user_config = util.nesteddict()
'''
self.user_config["userid"]["ex_id"]["f_symbols_whitelist"] = []
self.user_config["userid"]["ex_id"]["f_symbols_blacklist"] = []
self.user_config["userid"]["ex_id"]["f_symbols_auto"] = 0
self.user_config["userid"]["ex_id"]["f_long_hold"] = ["ETH", "BTC", "USDT", "USD", "EOS"]
self.user_config["userid"]["ex_id"]["f_quote"] = "ETH"
self.user_config["userid"]["ex_id"]["f_quote_amount"] = 0
self.user_config["userid"]["ex_id"]["f_fiat_display_currency"] = "USDT"
self.user_config["userid"]["ex_id"]["f_max_open_trades"] = 0
self.user_config["userid"]["ex_id"]["f_stoploss_rate"] = 0
self.user_config["userid"]["ex_id"]["f_trailing_stop_rate"] = 0
self.user_config["userid"]["ex_id"]["f_trailing_stop_rate_positive"] = 0
self.user_config["userid"]["ex_id"]["f_trailing_stop_channel"] = 0
self.user_config["userid"]["ex_id"]["f_strategy"] = ""
self.user_config["userid"]["ex_id"]["symbols"]["symbol"]["f_max_open_trades"] = 0
self.user_config["userid"]["ex_id"]["symbols"]["symbol"]["f_stoploss_rate"] = 0
self.user_config["userid"]["ex_id"]["symbols"]["symbol"]["f_trailing_stop_rate"] = 0
self.user_config["userid"]["ex_id"]["symbols"]["symbol"]["f_trailing_stop_rate_positive"] = 0
self.user_config["userid"]["ex_id"]["symbols"]["symbol"]["f_trailing_stop_channel"] = 0
self.user_config["userid"]["ex_id"]["symbols"]["symbol"]["f_strategy"] = ""
'''
self.user_exchange = util.nesteddict()
#self.user_exchange["userid"]["ex_id"] = None
self.user_strategy = util.nesteddict()
#self.user_strategy["userid"]["ex_id"]["symbol"]['timeframe'] = None
self.exchange_whitelist_auto = util.nesteddict()
#self.exchange_whitelist_auto["ex_id"] = []
self.user_balances = util.nesteddict()
#self.user_balances["userid"]["ex_id"]["symbol"] = None
self.userid_system = 0
self.queue_thread = queue.Queue()
self.load_system_conifg()
self.load_user_conifg()
self.refresh_whitelist_all()
self.load_system_strategy()
self.load_user_strategy()
self.load_user_balances()
self.ex_symbols = util.nesteddict()
t_markets = db.Session().query(db.t_markets).all()
for t_market in t_markets:
if not self.ex_symbols[t_market.f_ex_id]:
self.ex_symbols[t_market.f_ex_id] = [t_market.f_symbol]
else:
self.ex_symbols[t_market.f_ex_id].append(t_market.f_symbol)
def index(self, site=None):
if site is None:
site = 'null'
else:
session = db.Session()
# decode for valid json string
site = web.as_json(db.Site.get(session, int(site))).decode('utf-8')
session.close()
return web.render('map.html', site=site).render('html', doctype='html')
def create_campaign():
session = db.Session()
data = json.loads(request.data)
hospital_id = request.args.get('hospital_id', 0)
# hospital = session.query(db.Hospital).filter_by(_id=hospital_id).first()
hospital = session.query(db.Hospital).first()
name = data['name']
message = data['message']
bloodtypes = data['bloodtypes']
start_date = datetime.datetime.now()
end_date = datetime.datetime.now() + datetime.timedelta(days=10)
campaign = db.Campaign(hospital._id, name, message, start_date, end_date)
session.add(campaign)
session.commit()
for bloodtype in bloodtypes:
campaign_blood = db.CampaignBlood(campaign._id, bloodtype)
session.add(campaign_blood)
session.commit()
gcmClient = GCMClient(api_key=os.environ.get('GCM_API_KEY'))
alert = {
'subject': 'Fushate e re',
'message': campaign.hospital.name,
'data': {
'id': campaign._id,
'name': name,
'hospital': {
'name': campaign.hospital.name,
'latitude': campaign.hospital.latitude,
'longitude': campaign.hospital.longitude,
},
'message': message,
'start_date': to_timestamp(start_date),
'end_date': to_timestamp(end_date)
}
}
interested_users = session.query(db.User).filter(db.User.blood_type.in_(bloodtypes))
gcm_id_list = [user.gcm_id for user in interested_users]
session.close()
response = gcmClient.send(gcm_id_list, alert, time_to_live=3600)
if response:
return ApiResponse({
'status': 'ok'
})
else:
return ApiResponse({
'status': 'some error occurred'
})
def page_ricerca():
session = db.Session()
margine1 = createDateTime(request.form["data5"])
margine2 = createDateTime(request.form["data6"])
risultati = session.query(db.Registrazione).filter(
db.and_(db.Registrazione.orario >= margine1,
db.Registrazione.orario <= margine2)).all()
session.close()
return render_template("dashboard.htm",
registrazioni=risultati,
alternativa=True)
def page_wiki(key: str):
db_session = db.Session()
wiki_page = db_session.query(db.WikiEntry).filter_by(key=key).one_or_none()
if request.method == "GET":
wiki_latest_edit = db_session.query(db.WikiLog).filter_by(edited_key=key) \
.order_by(db.WikiLog.timestamp.desc()).first()
db_session.close()
if wiki_page is None:
return render_template("wiki.html", key=key, config=config)
converted_md = Markup(
markdown2.markdown(wiki_page.content.replace("<", "<"),
extras=[
"spoiler", "tables", "smarty-pants",
"fenced-code-blocks"
]))
return render_template("wiki.html",
key=key,
wiki_page=wiki_page,
converted_md=converted_md,
wiki_log=wiki_latest_edit,
config=config)
elif request.method == "POST":
user_id = fl_session.get('user_id')
user = db_session.query(db.Royal).filter_by(id=user_id).one()
if user_id is None:
db_session.close()
return redirect(url_for("page_login"))
if wiki_page is None:
wiki_page = db.WikiEntry(key=key,
content=request.form.get("content"))
db_session.add(wiki_page)
db_session.flush()
else:
wiki_page.content = request.form.get("content")
edit_reason = request.form.get("reason")
new_log = db.WikiLog(editor=user,
edited_key=key,
timestamp=datetime.datetime.now(),
reason=edit_reason)
db_session.add(new_log)
db_session.commit()
try:
telegram_bot.send_message(
config["Telegram"]["main_group"],
f'ℹ️ La pagina wiki <a href="https://ryg.steffo.eu/wiki/{key}">{key}</a> è stata'
f' modificata da'
f' <a href="https://ryg.steffo.eu/profile/{user.username}">{user.username}</a>:'
f' {"<i>Nessun motivo specificato.</i>" if not edit_reason else edit_reason}\n',
parse_mode="HTML",
disable_web_page_preview=True,
disable_notification=True)
except Exception:
pass
return redirect(url_for("page_wiki", key=key))
def imagelist_json(self, site=None, by=None):
session = db.Session()
imagelist = session.query(db.Image).order_by(
db.Image._site, db.Image.time)
if site:
imagelist.filter(db.Image._site == site)
if by:
imagelist.filter(db.Image._by == by)
res = web.as_json(imagelist.all())
session.close()
return bytearray(res)
def add_dummy():
"""
Add a dummy module download every time this is hit
"""
insert_raw_deployment(db.Session(),
'nibz',
'puppetboard',
['awesome', 'ci', 'production'],
datetime.now())
return 'True'
def try_delete_adlink(keyword):
session = db.Session()
adlinks = session.query(AdLink).filter_by(keyword=keyword).all()
if len(adlinks) == 0:
session.close()
return False
for adlink in adlinks:
session.delete(adlink)
session.commit()
session.close()
return True
def logout():
session = db.Session()
hospital_id = request.args.get('hospital_id', 0)
# TODO: shiko per injection
hospital = session.query(db.Hospital).filter_by(_id=hospital_id).first()
hospital.logout()
session.add(hospital)
session.commit()
session.close()
return ApiResponse({
'status': 'ok'
})
def actualclimate_json(self, site=47):
session = db.Session()
web.setmime(web.mime.json)
now = datetime.now()
yesterday = now - timedelta(hours=24)
res = {'time': now}
for dsid in range(1493, 1502):
ds = db.Timeseries.get(session, dsid)
t, v = ds.asarray(start=yesterday)
res[ds.name.split(',')[0].strip().replace(' ', '_')] = {
'min': v.min(), 'max': v.max(), 'mean': v.mean()}
return web.as_json(res)
def with_instrument(self, instrumentid):
web.setmime(web.mime.json)
session = db.Session()
sites = []
print("instrument id %s" % instrumentid)
try:
inst = db.Datasource.get(session, int(instrumentid))
sites = sorted(set(i.site for i in inst.sites))
print("Sites: %s" % sites.__len__())
finally:
session.close()
return web.as_json(sites)
def page_music_individual(discord_id: str):
db_session = db.Session()
discord = db_session.query(
db.Discord).filter_by(discord_id=discord_id).one_or_none()
if discord is None:
db_session.close()
abort(404)
return
songs = db_session.execute(query_discord_music.single_top_songs,
{"discordid": discord.discord_id})
db_session.close()
return render_template("topsongs.html", songs=songs, discord=discord)
def new_func(bot: telegram.Bot, update: telegram.Update):
try:
session = db.Session()
return func(bot, update, session)
except Exception:
logger.error(f"Database error: {sys.exc_info()}")
sentry.captureException()
finally:
try:
session.close()
except Exception:
pass
def refresh_whitelist(self, ex_id):
#logger.debug(self.to_string() + "refresh_whitelist({0}) start".format(ex_id))
whitelist = []
for t_markets in db.Session().query(db.t_markets).filter(
db.t_markets.f_ex_id == ex_id,
db.t_markets.f_recommend >= 1.0,
).all():
whitelist.append(t_markets.f_symbol)
self.exchange_whitelist_auto[ex_id] = whitelist
logger.debug(
self.to_string() +
"refresh_whitelist({0}) len={1}".format(ex_id, len(whitelist)))
def delete_key(key):
session = db.Session()
keys = session.query(Keys).filter_by(key=key).all()
if len(keys) == 0:
session.close()
return False
for key in keys:
session.delete(key)
session.commit()
session.close()
return True
def load(self):
session = db.Session()
q = session.query(db.Person).filter(db.Person.active == True)
self.dict = {}
allpersons = q.all()
for person in allpersons:
self.dict[person.username] = User(person.username,
person.access_level,
person.password)
def cmd_diario(bot: Bot, update: Update):
session = db.Session()
try:
user = session.query(db.Telegram).filter_by(
telegram_id=update.message.from_user.id).one_or_none()
if user is None:
bot.send_message(
update.message.chat.id,
"⚠ Il tuo account Telegram non è registrato al RYGdb!"
" Registrati con `/register@royalgamesbot <nomeutenteryg>`.",
parse_mode="Markdown")
return
try:
text = update.message.text.split(" ", 1)[1]
author = session.query(db.Telegram).filter_by(
telegram_id=update.message.from_user.id).one_or_none()
saver = author
except IndexError:
if update.message.reply_to_message is None:
bot.send_message(
update.message.chat.id,
f"⚠ Non hai specificato cosa aggiungere al diario!\n\n"
f"Puoi rispondere `/diario@royalgamesbot` al messaggio che vuoi salvare nel diario"
f" oppure scrivere `/diario@royalgamesbot <messaggio>`"
f" per aggiungere quel messaggio nel diario.",
parse_mode="Markdown")
return
text = update.message.reply_to_message.text
author = session.query(db.Telegram)\
.filter_by(telegram_id=update.message.reply_to_message.from_user.id)\
.one_or_none()
saver = session.query(db.Telegram).filter_by(
telegram_id=update.message.from_user.id).one_or_none()
if text is None:
bot.send_message(
update.message.chat.id,
f"⚠ Il messaggio a cui hai risposto non contiene testo.")
return
diario = db.Diario(timestamp=datetime.datetime.now(),
saver=saver,
author=author,
text=text)
session.add(diario)
session.commit()
bot.send_message(
update.message.chat.id,
f"✅ Riga [#{diario.id}](https://ryg.steffo.eu/diario#entry-{diario.id}) aggiunta al diario!",
parse_mode="Markdown",
disable_web_page_preview=True)
except Exception:
raise
finally:
session.close()
def login():
"""
This POST endpoint handles user logins and returns a JWT on success
Some parts of this are taken from my person site.
https://github.com/physics31415/CarServiceHistoryAPI/blob/master/auth.py
:return: response object with JWT or error
"""
req = request.json
keys = req.keys()
#error checking
if 'username' not in keys:
return buildResponse(json.dumps("Missing parameter username"), 400)
elif 'password' not in keys:
return buildResponse(json.dumps("Missing parameter password"), 400)
password = req['password']
username = req['username']
session = db.Session()
users = session.query(User)
user = None
for usr in users:
if usr.username == req['username']:
user = usr
if not user:
session.close()
return buildResponse(json.dumps("Username not found in system"), 404)
salt = user.salt
stored_pw = user.hashed_pw
# validate's user provided password
if validatePassword(password, salt, stored_pw):
token = jwt.encode(
{
'username':
username,
'exp':
(datetime.datetime.utcnow() + datetime.timedelta(minutes=120))
}, JWT_SECRET)
user.session_token = token.decode('utf-8')
session.commit()
session.close()
return buildResponse(json.dumps({'token': token.decode('utf-8')}), 200)
else:
session.close()
return buildResponse("User password incorrect", 401)
def safe_handler(*args, **kwargs):
session = db.Session()
session_token = request.args.get('session_token', '')
user_id = request.args.get('user_id', 0)
user = session.query(db.User).filter_by(user_id=user_id).first()
if user and utils.str_equal(user.session_token, session_token) and \
utils.to_timestamp(user.session_token_expires_at) > time.time():
response = handler(*args, **kwargs)
else:
response = ApiResponse(config.ACCESS_DENIED_MSG, status='403')
session.close()
return response
async def leave(ctx):
"""Removes a user from a particular side"""
with db.Session() as session:
active_debate = session.query(Storage).filter_by(
guild=ctx.guild.id).one_or_none()
role1 = discord.utils.get(ctx.guild.roles, id=active_debate.side1_role)
role2 = discord.utils.get(ctx.guild.roles, id=active_debate.side2_role)
sideroles = [role1, role2]
for role in ctx.author.roles:
if role in sideroles:
await ctx.author.remove_roles(role)
await ctx.send("{} has left".format(ctx.author.mention))
def __call__(self, commit=False, preload=False):
session = db.Session()
logs = []
errors = {}
start = 0 + self.descr.skiplines
end = self.sheet.nrows
cherrypy.log("Rows in calling mm: %d" % self.sheet.nrows)
# TODO: Make the importrow more performant
# if self.sheet.nrows > 50:
# raise ValueError("Your file has more than 50 rows. This can lead to"
# "a server timeout. Please split your file and "
# "proceed!")
if preload:
self.preload()
self._preload = preload
try:
for row in range(start, end):
print(row, " / ", end)
if self.sheet.cell_value(row, 1):
row_has_error = False
for valuetype_column in self.descr.columns:
try:
log = self.importrow(
session, row, valuetype_column=valuetype_column, commit=commit)
logs.append(dict(row=row,
error=False,
log=log))
except LogImportError as e:
if not e.is_valuetype_error and row_has_error:
continue
errors[e.row] = e.text
logs.append(dict(row=row,
error=True,
log=e.text))
row_has_error = True
if commit and not errors:
s = "Commited approx. %s" % len(logs)
cherrypy.log(s)
session.commit()
finally:
session.close()
return logs, not errors
def report_main():
session = db.Session()
top_pokemon = db.get_top_pokemon(session)
bottom_pokemon = db.get_top_pokemon(session, order='ASC')
bottom_sightings = db.get_all_sightings(session,
[r[0] for r in bottom_pokemon])
stage2_pokemon = db.get_stage2_pokemon(session)
if stage2_pokemon:
stage2_sightings = db.get_all_sightings(session,
[r[0] for r in stage2_pokemon])
else:
stage2_sightings = []
js_data = {
'charts_data': {
'punchcard': db.get_punch_card(session),
'top30': [(POKEMON_NAMES[r[0]], r[1]) for r in top_pokemon],
'bottom30': [(POKEMON_NAMES[r[0]], r[1]) for r in bottom_pokemon],
'stage2': [(POKEMON_NAMES[r[0]], r[1]) for r in stage2_pokemon],
},
'maps_data': {
'bottom30': [sighting_to_marker(s) for s in bottom_sightings],
'stage2': [sighting_to_marker(s) for s in stage2_sightings],
},
'map_center': utils.get_map_center(),
'zoom': 13,
}
icons = {
'top30': [(r[0], POKEMON_NAMES[r[0]]) for r in top_pokemon],
'bottom30': [(r[0], POKEMON_NAMES[r[0]]) for r in bottom_pokemon],
'stage2': [(r[0], POKEMON_NAMES[r[0]]) for r in stage2_pokemon],
'nonexistent':
[(r, POKEMON_NAMES[r]) for r in db.get_nonexistent_pokemon(session)]
}
session_stats = db.get_session_stats(session)
session.close()
area = utils.get_scan_area()
return render_template(
'report.html',
current_date=datetime.now(),
area_name=config.AREA_NAME,
area_size=area,
total_spawn_count=session_stats['count'],
spawns_per_hour=session_stats['per_hour'],
session_start=session_stats['start'],
session_end=session_stats['end'],
session_length_hours=int(session_stats['length_hours']),
js_data=js_data,
icons=icons,
google_maps_key=config.GOOGLE_MAPS_KEY,
)
def get_pokemarkers():
markers = []
session = db.Session()
if args.after == 0:
pokemons = db.get_sightings(session)
else:
pokemons = db.get_sightings_after(session, args.after)
forts = db.get_forts(session)
pokestops = db.get_pokestops(session)
session.close()
for pokemon in pokemons:
markers.append({
'id': 'pokemon-{}'.format(pokemon.id),
'type': 'pokemon',
'trash': pokemon.pokemon_id in config.TRASH_IDS,
'name': POKEMON_NAMES[pokemon.pokemon_id],
'pokemon_id': pokemon.pokemon_id,
'lat': pokemon.lat,
'lon': pokemon.lon,
'expires_at': pokemon.expire_timestamp,
})
for fort in forts:
if fort['guard_pokemon_id']:
pokemon_name = POKEMON_NAMES[fort['guard_pokemon_id']]
else:
pokemon_name = 'Empty'
markers.append({
'id': 'fort-{}'.format(fort['fort_id']),
'sighting_id': fort['id'],
'type': 'fort',
'prestige': fort['prestige'],
'pokemon_id': fort['guard_pokemon_id'],
'pokemon_name': pokemon_name,
'team': fort['team'],
'lat': fort['lat'],
'lon': fort['lon'],
})
for pokestop in pokestops:
markers.append({
'id': 'stop-{}'.format(pokestop['id']),
'type': 'pokestop',
'lat': pokestop['lat'],
'lon': pokestop['lon'],
})
return markers
def createAccount():
"""
POST endpoint to create a new user. Some of the code was taken from my personal
website's code in order to complete it on time for our iteration 1 deadline
https://github.com/physics31415/CarServiceHistoryAPI/blob/master/auth.py
:return: response object
"""
req = request.json
if not req:
return buildResponse(json.dumps("Missing request body"), 400)
keys = req.keys()
#error checking
if 'email' not in keys or req['email'] == None:
return buildResponse(json.dumps("Missing parameter email"), 400)
elif 'username' not in keys or req['username'] == None or req[
'username'] == "":
return buildResponse(json.dumps("Missing parameter username"), 400)
elif 'password' not in keys or req['password'] == None or req[
'password'] == "":
return buildResponse(json.dumps("Missing parameter password"), 400)
elif 'secret_code' not in keys or req['secret_code'] == None:
return buildResponse(json.dumps("Missing parameter secret_code"), 400)
email = req['email']
#regex from https://www.geeksforgeeks.org/check-if-email-address-valid-or-not-in-python/
regex = re.compile("^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$")
if not regex.match(email):
return buildResponse(json.dumps("Invalid email"), 400)
# incorrect secrete code to create an account
if req['secret_code'].strip() != CREATE_ACCOUNT_CODE:
return buildResponse(json.dumps("Wrong secret_code"), 401)
# check for duplicate usernames
session = db.Session()
users = session.query(User)
for user in users:
if user.username == req['username']:
session.close()
return buildResponse("Username already registered", 400)
session.close()
user = User(req['username'], req['email'], req['password'])
db.addObject(user)
return buildResponse(json.dumps("User was added successfully"), 200)
def cmd_ban(bot: Bot, update: Update):
if datetime.date.today() != datetime.date(2019, 4, 1):
bot.send_message(update.message.chat.id,
"⚠ Non è il giorno adatto per bannare persone!")
return
session = db.Session()
try:
last_bans = session.query(db.AprilFoolsBan).filter(
db.AprilFoolsBan.datetime >
(datetime.datetime.now() - datetime.timedelta(minutes=15))).all()
if len(last_bans) > 0:
bot.send_message(
update.message.chat.id, "⚠ /ban è in cooldown.\n"
"Può essere usato solo 1 volta ogni 15 minuti!")
return
try:
arg = update.message.text.split(" ", 1)[1]
except IndexError:
bot.send_message(update.message.chat.id,
"⚠ Devi specificare un bersaglio!")
return
target_user = session.query(
db.Telegram).filter_by(username=arg).one_or_none()
if target_user is None:
bot.send_message(
update.message.chat.id,
"⚠ Il bersaglio specificato non esiste nel RYGdb.\n"
"Le possibilità sono due: non è un membro RYG, "
"oppure non si è ancora registrato e va bannato manualmente.")
return
if int(target_user.telegram_id) == 25167391:
bot.send_message(
update.message.chat.id,
"⚠ Il creatore della chat non può essere espulso.")
return
bannerino = db.AprilFoolsBan(from_user_id=update.message.from_user.id,
to_user_id=target_user.telegram_id,
datetime=datetime.datetime.now())
session.add(bannerino)
session.commit()
bot.kick_chat_member(update.message.chat.id, target_user.telegram_id)
bot.unban_chat_member(update.message.chat.id, target_user.telegram_id)
try:
bot.send_message(target_user.telegram_id,
"https://t.me/joinchat/AYAGH0TEav8WcbPVfNe75A")
except Exception:
pass
bot.send_message(update.message.chat.id, "🔨")
except Exception as e:
pass
finally:
session.close()
def list_deadlines(message):
attachments = []
session = db.Session()
error = False
try:
for deadline in session.query(Deadline).order_by(Deadline.date):
days = (deadline.date - datetime.date.today()).days
if days < 0:
continue
attach = {"mrkdwn_in": ["text"]}
try:
deadline_text = '<{cfp_url}|{conf_name}>'.format(
cfp_url=get_conf_wikicfp_url(deadline.item),
conf_name=deadline.item)
except:
deadline_text = deadline.item
if days > 1:
abstract_message = ""
if deadline.abstract_date != None:
abstract_days = (deadline.abstract_date -
datetime.date.today()).days
if abstract_days < 0:
abstract_message = ""
elif abstract_days == 0:
abstract_message = " (*abstract due TODAY!*)"
elif abstract_days == 1:
abstract_message = " (abstract due tomorrow)"
else:
abstract_message = " (abstract due in {} days)".format(
abstract_days)
attach["text"] = "{} days until {}{}".format(
days, deadline_text, abstract_message)
elif days == 1:
attach["text"] = "*{} tomorrow!*".format(deadline_text)
else:
attach["text"] = "*{} TODAY!*".format(deadline_text)
attach["color"] = "#ff0000"
if days < 7 and days > 0:
attach["color"] = "#ffff00"
attachments.append(attach)
except:
session.rollback()
message.reply("Exception on query!")
error = True
raise
finally:
if not error:
if attachments:
message.send_webapi('', json.dumps(attachments))
else:
message.reply("No deadlines!")
session.close()
def check_give_key(user_data):
session = db.Session()
ref_key = session.query(User).get(user_data['chat_id']).sub_keys
ref_count = get_invited_users_count(user_data)
key_away = session.query(User).get(user_data['chat_id']).keys_away
if ref_count % 3 == 0 and ref_count != 0:
session.query(User).get(user_data['chat_id']).sub_keys += 1
if ref_count * ref_key > key_away:
return True
else:
return False
else:
return False
def new_ad_link(keyword):
session = db.Session()
# try:
adlink = AdLink(uuid=str(uuid.uuid4()), keyword=keyword)
session.add(adlink)
session.commit()
result = adlink.id
# except Exception:
# session.close()
# return None
session.close()
return result
