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