def on_banphrase_update(self, data, conn): try: banphrase_id = int(data['banphrase_id']) except (KeyError, ValueError): log.warn('No banphrase ID found in on_banphrase_update') return False updated_banphrase = find(lambda banphrase: banphrase.id == banphrase_id, self.banphrases) if updated_banphrase: with DBManager.create_session_scope(expire_on_commit=False) as db_session: db_session.add(updated_banphrase) db_session.refresh(updated_banphrase) db_session.expunge(updated_banphrase) else: with DBManager.create_session_scope(expire_on_commit=False) as db_session: updated_banphrase = db_session.query(Banphrase).filter_by(id=banphrase_id).one_or_none() db_session.expunge_all() if updated_banphrase is not None: self.db_session.add(updated_banphrase.data) if updated_banphrase: if updated_banphrase not in self.banphrases: self.banphrases.append(updated_banphrase) if updated_banphrase.enabled is True and updated_banphrase not in self.enabled_banphrases: self.enabled_banphrases.append(updated_banphrase) for banphrase in self.enabled_banphrases: if banphrase.enabled is False: self.enabled_banphrases.remove(banphrase)
def create_stream_chunk(self, status): if self.current_stream_chunk is not None: # There's already a stream chunk started! self.current_stream_chunk.chunk_end = datetime.datetime.now() DBManager.session_add_expunge(self.current_stream_chunk) stream_chunk = None with DBManager.create_session_scope( expire_on_commit=False) as db_session: stream_chunk = db_session.query(StreamChunk).filter_by( broadcast_id=status['broadcast_id']).one_or_none() if stream_chunk is None: log.info('Creating stream chunk, from create_stream_chunk') stream_chunk = StreamChunk(self.current_stream, status['broadcast_id'], status['created_at']) self.current_stream_chunk = stream_chunk db_session.add(stream_chunk) db_session.commit() else: log.info('We already have a stream chunk!') self.current_stream_chunk = stream_chunk stream_chunk = None db_session.expunge_all() if stream_chunk: self.current_stream.stream_chunks.append(stream_chunk)
def on_banphrase_update(self, data, conn): try: banphrase_id = int(data['banphrase_id']) except (KeyError, ValueError): log.warn('No banphrase ID found in on_banphrase_update') return False updated_banphrase = find( lambda banphrase: banphrase.id == banphrase_id, self.banphrases) if updated_banphrase: with DBManager.create_session_scope( expire_on_commit=False) as db_session: db_session.add(updated_banphrase) db_session.refresh(updated_banphrase) db_session.expunge(updated_banphrase) else: with DBManager.create_session_scope( expire_on_commit=False) as db_session: updated_banphrase = db_session.query(Banphrase).filter_by( id=banphrase_id).one_or_none() db_session.expunge_all() if updated_banphrase is not None: self.db_session.add(updated_banphrase.data) if updated_banphrase: if updated_banphrase not in self.banphrases: self.banphrases.append(updated_banphrase) if updated_banphrase.enabled is True and updated_banphrase not in self.enabled_banphrases: self.enabled_banphrases.append(updated_banphrase) for banphrase in self.enabled_banphrases: if banphrase.enabled is False: self.enabled_banphrases.remove(banphrase)
def generate_token_for_user(self, user, scopes): if not user: return None token = APIToken(user, scopes) DBManager.session_add_expunge(token) return token
def refresh_video_url(self): if self.online is False: return if self.current_stream_chunk is None or self.current_stream is None: return log.info('Attempting to fetch video url for broadcast {0}'.format( self.current_stream_chunk.broadcast_id)) stream_chunk = self.current_stream_chunk if self.current_stream_chunk.video_url is None else None video_url, video_preview_image_url, video_recorded_at = self.fetch_video_url( stream_chunk) if video_url is not None: log.info('Successfully fetched a video url: {0}'.format(video_url)) if self.current_stream_chunk is None or self.current_stream_chunk.video_url is None: with DBManager.create_session_scope( expire_on_commit=False) as db_session: self.current_stream_chunk.video_url = video_url self.current_stream_chunk.video_preview_image_url = video_preview_image_url db_session.add(self.current_stream_chunk) db_session.commit() db_session.expunge_all() log.info('Successfully commited video url data.') elif self.current_stream_chunk.video_url != video_url: # End current stream chunk self.current_stream_chunk.chunk_end = datetime.datetime.now() DBManager.session_add_expunge(self.current_stream_chunk) with DBManager.create_session_scope( expire_on_commit=False) as db_session: stream_chunk = StreamChunk( self.current_stream, self.current_stream_chunk.broadcast_id, video_recorded_at) self.current_stream_chunk = stream_chunk self.current_stream_chunk.video_url = video_url self.current_stream_chunk.video_preview_image_url = video_preview_image_url db_session.add(self.current_stream_chunk) db_session.commit() db_session.expunge_all() log.info( 'Successfully commited video url data in a new chunk.') else: log.info('Not video for broadcast found')
def get_user(username): session = DBManager.create_session() user = session.query(User).filter_by(username=username).one_or_none() if user is None: return make_response(jsonify({'error': 'Not found'}), 404) rank = session.query(func.Count(User.id)).filter(User.points > user.points).one() rank = rank[0] + 1 session.close() if user: accessible_data = { 'id': user.id, 'username': user.username, 'username_raw': user.username_raw, 'points': user.points, 'rank': rank, 'level': user.level, 'last_seen': user.last_seen, 'last_active': user.last_active, 'subscriber': user.subscriber, 'num_lines': user.num_lines, 'minutes_in_chat_online': user.minutes_in_chat_online, 'minutes_in_chat_offline': user.minutes_in_chat_offline, 'banned': user.banned, 'ignored': user.ignored, } return jsonify(accessible_data) return make_response(jsonify({'error': 'Not found'}), 404)
def command_remove(command_id, **options): with DBManager.create_session_scope() as db_session: command = db_session.query(Command).filter_by(id=command_id).one_or_none() if command is None: return make_response(jsonify({'error': 'Invalid command ID'}), 404) if command.level > options['user'].level: abort(403) log_msg = 'The !{} command has been removed'.format(command.command.split('|')[0]) AdminLogManager.add_entry('Command removed', options['user'], log_msg) db_session.delete(command.data) db_session.delete(command) payload = { 'event': 'command.remove', 'data': { 'command_id': command_id } } payload_bytes = json.dumps(payload).encode('utf-8') try: with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as client: client.connect(config['sock']['sock_file']) client.sendall(payload_bytes) return make_response(jsonify({'success': 'good job'})) except: log.exception('???') return make_response(jsonify({'error': 'Could not push update'}))
def pleblist_next(): if not request.method == 'POST': return make_response(jsonify({'error': 'Invalid request method'}), 405) if 'song_id' not in request.form: return make_response(jsonify({'error': 'Missing data song_id'}), 400) if 'password' not in request.form: return make_response(jsonify({'error': 'Missing data password'}), 400) salted_password = generate_password_hash(config['web']['pleblist_password'], config['web']['pleblist_password_salt']) try: user_password = base64.b64decode(request.form['password']) except binascii.Error: return make_response(jsonify({'error': 'Invalid data password'}), 400) if not user_password == salted_password: return make_response(jsonify({'error': 'Invalid password'}), 401) with DBManager.create_session_scope() as session: try: current_song = session.query(PleblistSong).filter(PleblistSong.id == int(request.form['song_id'])).order_by(PleblistSong.date_added.asc()).first() except ValueError: return make_response(jsonify({'error': 'Invalid data song_id'}), 400) if current_song is None: return make_response(jsonify({'error': 'No song active in the pleblist'}), 404) current_song.date_played = datetime.datetime.now() session.commit() # TODO: Add more data. # Was this song forcefully skipped? Or did it end naturally. return jsonify({'message': 'Success!'})
def enable(self, bot): self.bot = bot HandlerManager.add_handler('on_message', self.on_message, priority=100) HandlerManager.add_handler('on_commit', self.on_commit) if bot: self.run_later = bot.execute_delayed if 'safebrowsingapi' in bot.config['main']: # XXX: This should be loaded as a setting instead. # There needs to be a setting for settings to have them as "passwords" # so they're not displayed openly self.safeBrowsingAPI = SafeBrowsingAPI( bot.config['main']['safebrowsingapi'], bot.nickname, bot.version) else: self.safeBrowsingAPI = None if self.db_session is not None: self.db_session.commit() self.db_session.close() self.db_session = None self.db_session = DBManager.create_session() self.blacklisted_links = [] for link in self.db_session.query(BlacklistedLink): self.blacklisted_links.append(link) self.whitelisted_links = [] for link in self.db_session.query(WhitelistedLink): self.whitelisted_links.append(link)
def authorized(): try: resp = twitch.authorized_response() except OAuthException: log.exception('An exception was caught while authorizing') next_url = get_next_url(request, 'state') return redirect(next_url) print(resp) if resp is None: log.warn('Access denied: reason={}, error={}'.format( request.args['error'], request.args['error_description'])) next_url = get_next_url(request, 'state') return redirect(next_url) elif type(resp) is OAuthException: log.warn(resp.message) log.warn(resp.data) log.warn(resp.type) next_url = get_next_url(request, 'state') return redirect(next_url) session['twitch_token'] = (resp['access_token'], ) me = twitch.get('user') level = 100 with DBManager.create_session_scope() as db_session: db_user = db_session.query(User).filter_by( username=me.data['name'].lower()).one_or_none() if db_user: level = db_user.level session['user'] = { 'username': me.data['name'], 'username_raw': me.data['display_name'], 'level': level, } next_url = get_next_url(request, 'state') return redirect(next_url)
def enable(self, bot): self.bot = bot HandlerManager.add_handler('on_message', self.on_message, priority=100) HandlerManager.add_handler('on_commit', self.on_commit) if bot: self.run_later = bot.execute_delayed if 'safebrowsingapi' in bot.config['main']: # XXX: This should be loaded as a setting instead. # There needs to be a setting for settings to have them as "passwords" # so they're not displayed openly self.safeBrowsingAPI = SafeBrowsingAPI(bot.config['main']['safebrowsingapi'], bot.nickname, bot.version) else: self.safeBrowsingAPI = None if self.db_session is not None: self.db_session.commit() self.db_session.close() self.db_session = None self.db_session = DBManager.create_session() self.blacklisted_links = [] for link in self.db_session.query(BlacklistedLink): self.blacklisted_links.append(link) self.whitelisted_links = [] for link in self.db_session.query(WhitelistedLink): self.whitelisted_links.append(link)
def nl_pos(bot, source, message, event, args): # XXX: This should be a module # These phrases should be module settings nl_0 = "{username} has not typed any messages in this channel BibleThump" nl_pos = "{username} is rank {nl_pos} line-farmer in this channel!" if message: tmp_username = message.split(" ")[0].strip().lower() user = bot.users.find(tmp_username) if user: username = user.username_raw num_lines = user.num_lines else: username = tmp_username num_lines = 0 else: username = source.username_raw num_lines = source.num_lines phrase_data = {"username": username, "num_lines": num_lines} if num_lines <= 0: bot.say(nl_0.format(**phrase_data)) else: with DBManager.create_session_scope() as db_session: query_data = db_session.query(func.count(User.id)).filter(User.num_lines > num_lines).one() phrase_data["nl_pos"] = int(query_data[0]) + 1 bot.say(nl_pos.format(**phrase_data))
def post(self, row_id, **options): args = self.post_parser.parse_args() try: new_state = int(args['new_state']) except (ValueError, KeyError): return {'error': 'Invalid `new_state` parameter.'}, 400 with DBManager.create_session_scope() as db_session: row = db_session.query(Banphrase).filter_by(id=row_id).one_or_none() if not row: return { 'error': 'Banphrase with this ID not found' }, 404 row.enabled = True if new_state == 1 else False db_session.commit() payload = { 'id': row.id, 'new_state': row.enabled, } AdminLogManager.post('Banphrase toggled', options['user'], 'Enabled' if row.enabled else 'Disabled', row.phrase) SocketClientManager.send('banphrase.update', payload) return {'success': 'successful toggle', 'new_state': new_state}
def post(self): args = self.post_parser.parse_args() try: pajbot.web.utils.pleblist_login(args['password'], app.bot_config) except pajbot.exc.InvalidLogin as e: return {'error': str(e)}, 401 with DBManager.create_session_scope() as session: try: current_song = session.query(PleblistSong).filter(PleblistSong.id == args['song_id']).order_by(PleblistSong.date_added.asc()).first() except ValueError: return { 'error': 'Invalid data song_id' }, 400 if current_song is None: return { 'error': 'No song active in the pleblist' }, 404 current_song.date_played = datetime.datetime.now() session.commit() # TODO: Add more data. # Was this song forcefully skipped? Or did it end naturally. return { 'success': 'got em!' }, 200
def stats_duels(): with DBManager.create_session_scope() as db_session: data = { 'top_5_winners': db_session.query(UserDuelStats).order_by( UserDuelStats.duels_won.desc())[:5], 'top_5_points_won': db_session.query(UserDuelStats).order_by( UserDuelStats.profit.desc())[:5], 'top_5_points_lost': db_session.query(UserDuelStats).order_by( UserDuelStats.profit.asc())[:5], 'top_5_losers': db_session.query(UserDuelStats).order_by( UserDuelStats.duels_lost.desc())[:5], 'top_5_winrate': db_session.query(UserDuelStats).filter( UserDuelStats.duels_won >= 5).order_by( UserDuelStats.winrate.desc())[:5], 'bottom_5_winrate': db_session.query(UserDuelStats).filter( UserDuelStats.duels_lost >= 5).order_by( UserDuelStats.winrate.asc())[:5], } return render_template('stats_duels.html', **data)
def pleblist_history_stream(stream_id): with DBManager.create_session_scope() as session: stream = session.query(Stream).filter_by( id=stream_id).one_or_none() if stream is None: return render_template('pleblist_history_404.html'), 404 q = session.query(PleblistSong, User).outerjoin( User, PleblistSong.user_id == User.id).filter( PleblistSong.stream_id == stream.id).order_by( PleblistSong.id.asc(), PleblistSong.id.asc()) songs = [] for song, user in q: song.user = user songs.append(song) total_length_left = sum([ song.skip_after or song.song_info.duration if song.date_played is None and song.song_info is not None else 0 for song in songs ]) first_unplayed_song = find(lambda song: song.date_played is None, songs) stream_chunks = session.query(StreamChunk).filter( StreamChunk.stream_id == stream.id).all() return render_template('pleblist_history.html', stream=stream, songs=songs, total_length_left=total_length_left, first_unplayed_song=first_unplayed_song, stream_chunks=stream_chunks)
def point_pos(bot, source, message, event, args): # XXX: This should be a module user = None # This phrase should be a module setting point_pos = "{username_w_verb} rank {point_pos} point-hoarder in this channel with {points} points." if message: tmp_username = message.split(" ")[0].strip().lower() user = bot.users.find(tmp_username) if not user: user = source phrase_data = {"points": user.points} if user == source: phrase_data["username_w_verb"] = "You are" else: phrase_data["username_w_verb"] = "{0} is".format(user.username_raw) if user.points > 0: with DBManager.create_session_scope() as db_session: query_data = db_session.query(func.count(User.id)).filter(User.points > user.points).one() phrase_data["point_pos"] = int(query_data[0]) + 1 bot.whisper(source.username, point_pos.format(**phrase_data))
def create_stream(self, status): log.info('Attempting to create a stream!') with DBManager.create_session_scope(expire_on_commit=False) as db_session: stream_chunk = db_session.query(StreamChunk).filter_by(broadcast_id=status['broadcast_id']).one_or_none() new_stream = False if stream_chunk is not None: stream = stream_chunk.stream else: log.info('checking if there is an active stream already') stream = db_session.query(Stream).filter_by(ended=False).order_by(Stream.stream_start.desc()).first() new_stream = stream is None if new_stream: log.info('No active stream, create new!') stream = Stream(status['created_at'], title=status['title']) db_session.add(stream) db_session.commit() log.info('Successfully added stream!') stream_chunk = StreamChunk(stream, status['broadcast_id'], status['created_at']) db_session.add(stream_chunk) db_session.commit() stream.stream_chunks.append(stream_chunk) log.info('Created stream chunk') self.current_stream = stream self.current_stream_chunk = stream_chunk db_session.expunge_all() if new_stream: HandlerManager.trigger('on_stream_start', stop_on_false=False) log.info('Successfully created a stream')
def timers(**options): with DBManager.create_session_scope() as db_session: return render_template('admin/timers.html', timers=db_session.query(Timer).all(), created=session.pop('timer_created_id', None), edited=session.pop('timer_edited_id', None))
def get_user(username): session = DBManager.create_session() user = session.query(User).filter_by(username=username).one_or_none() if user is None: return make_response(jsonify({'error': 'Not found'}), 404) rank = session.query(func.Count( User.id)).filter(User.points > user.points).one() rank = rank[0] + 1 session.close() if user: accessible_data = { 'id': user.id, 'username': user.username, 'username_raw': user.username_raw, 'points': user.points, 'rank': rank, 'level': user.level, 'last_seen': user.last_seen, 'last_active': user.last_active, 'subscriber': user.subscriber, 'num_lines': user.num_lines, 'minutes_in_chat_online': user.minutes_in_chat_online, 'minutes_in_chat_offline': user.minutes_in_chat_offline, 'banned': user.banned, 'ignored': user.ignored, } return jsonify(accessible_data) return make_response(jsonify({'error': 'Not found'}), 404)
def post(self): args = self.post_parser.parse_args() try: pajbot.web.utils.pleblist_login(args['password'], app.bot_config) except pajbot.exc.InvalidLogin as e: return {'error': str(e)}, 401 with DBManager.create_session_scope() as session: youtube_id = args['youtube_id'] current_stream = session.query(Stream).filter_by(ended=False).order_by(Stream.stream_start).first() if current_stream is None: return { 'error': 'Stream offline' }, 400 skip_after = args['skip_after'] log.info('Request song youtube ID: {}'.format(youtube_id)) song_requested = PleblistSong(current_stream.id, youtube_id, skip_after=skip_after) session.add(song_requested) song_info = session.query(PleblistSongInfo).filter_by(pleblist_song_youtube_id=youtube_id).first() if song_info is None and song_requested.song_info is None: PleblistManager.init(app.bot_config['youtube']['developer_key']) song_info = PleblistManager.create_pleblist_song_info(song_requested.youtube_id) if song_info is not False: session.add(song_info) session.commit() return { 'success': 'got em!' }, 200
def modules_edit(module_id, **options): module_manager = ModuleManager(None).load(do_reload=False) current_module = find(lambda m: m.ID == module_id, module_manager.all_modules) if current_module is None: return render_template('admin/module_404.html'), 404 sub_modules = [] for module in module_manager.all_modules: module.db_module = None with DBManager.create_session_scope() as db_session: for db_module in db_session.query(Module): module = find(lambda m: m.ID == db_module.id, module_manager.all_modules) if module: module.db_module = db_module if module.PARENT_MODULE == current_module.__class__: sub_modules.append(module) if current_module.db_module is None: return render_template('admin/module_404.html'), 404 if request.method == 'POST': form_values = {key: value for key, value in request.form.items()} res = current_module.parse_settings(**form_values) if res is False: return render_template('admin/module_404.html'), 404 current_module.db_module.settings = json.dumps(res) db_session.commit() settings = None try: settings = json.loads(current_module.db_module.settings) except (TypeError, ValueError): pass current_module.load(settings=settings) payload = { 'id': current_module.db_module.id, } SocketClientManager.send('module.update', payload) AdminLogManager.post('Module edited', options['user'], current_module.NAME) return render_template('admin/configure_module.html', module=current_module, sub_modules=sub_modules) else: settings = None try: settings = json.loads(current_module.db_module.settings) except (TypeError, ValueError): pass current_module.load(settings=settings) return render_template('admin/configure_module.html', module=current_module, sub_modules=sub_modules)
def get_current_song(stream_id): with DBManager.create_session_scope() as session: cur_song = session.query(PleblistSong).filter(PleblistSong.stream_id == stream_id, PleblistSong.date_played.is_(None)).order_by(PleblistSong.date_added.asc(), PleblistSong.id.asc()).first() if cur_song is None: return None session.expunge(cur_song) return cur_song
def __init__(self, bot): self.bot = bot self.current_stream_chunk = None # should this even exist? self.num_offlines = 0 self.first_offline = None self.num_viewers = 0 self.bot.execute_every(self.STATUS_CHECK_INTERVAL, self.refresh_stream_status) self.bot.execute_every(self.VIDEO_URL_CHECK_INTERVAL, self.refresh_video_url) """ This will load the latest stream so we can post an accurate "time since last online" figure. """ with DBManager.create_session_scope( expire_on_commit=False) as db_session: self.current_stream = db_session.query(Stream).filter_by( ended=False).order_by(Stream.stream_start.desc()).first() self.last_stream = db_session.query(Stream).filter_by( ended=True).order_by(Stream.stream_end.desc()).first() if self.current_stream: self.current_stream_chunk = db_session.query( StreamChunk).filter_by( stream_id=self.current_stream.id).order_by( StreamChunk.chunk_start.desc()).first() log.info('Set current stream chunk here to {0}'.format( self.current_stream_chunk)) db_session.expunge_all()
def commands(**options): from pajbot.models.command import CommandManager from pajbot.models.module import ModuleManager bot_commands = CommandManager( socket_manager=None, module_manager=ModuleManager(None).load(), bot=None).load(enabled=None) bot_commands_list = bot_commands.parse_for_web() custom_commands = [] point_commands = [] moderator_commands = [] for command in bot_commands_list: if command.id is None: continue if command.level > 100 or command.mod_only: moderator_commands.append(command) elif command.cost > 0: point_commands.append(command) else: custom_commands.append(command) with DBManager.create_session_scope() as db_session: commands_data = db_session.query(CommandData).options(joinedload(CommandData.user), joinedload(CommandData.user2)).all() return render_template( 'admin/commands.html', commands_data=commands_data, custom_commands=sorted(custom_commands, key=lambda f: f.command), point_commands=sorted(point_commands, key=lambda a: (a.cost, a.command)), moderator_commands=sorted(moderator_commands, key=lambda c: (c.level if c.mod_only is False else 500, c.command)), created=session.pop('command_created_id', None), edited=session.pop('command_edited_id', None))
def decks_warrior(): session = DBManager.create_session() decks = session.query(Deck).filter_by(deck_class='warrior').order_by(Deck.last_used.desc(), Deck.first_used.desc()).all() session.close() return render_template('decks/by_class.html', decks=decks, deck_class='Warrior')
def authorized(): try: resp = twitch.authorized_response() except OAuthException: log.exception('An exception was caught while authorizing') next_url = get_next_url(request, 'state') return redirect(next_url) print(resp) if resp is None: log.warn('Access denied: reason={}, error={}'.format(request.args['error'], request.args['error_description'])) next_url = get_next_url(request, 'state') return redirect(next_url) elif type(resp) is OAuthException: log.warn(resp.message) log.warn(resp.data) log.warn(resp.type) next_url = get_next_url(request, 'state') return redirect(next_url) session['twitch_token'] = (resp['access_token'], ) me = twitch.get('user') level = 100 with DBManager.create_session_scope() as db_session: db_user = db_session.query(User).filter_by(username=me.data['name'].lower()).one_or_none() if db_user: level = db_user.level session['user'] = { 'username': me.data['name'], 'username_raw': me.data['display_name'], 'level': level, } next_url = get_next_url(request, 'state') return redirect(next_url)
def generic_toggle(route_key, row_id, **options): valid_routes = { 'timer': Timer, 'banphrase': Banphrase, 'module': Module, } route_name = { 'timer': lambda x: x.name, 'banphrase': lambda x: x.phrase, 'module': lambda x: x.id, } route_title = { 'timer': 'Timer', 'banphrase': 'Banphrase', 'module': 'Module', } route_validator = { 'module': lambda x: validate_module(x.id) } if route_key not in valid_routes: return make_response(jsonify({'error': 'Invalid route.'}), 400) if 'new_state' not in request.form: return make_response(jsonify({'error': 'Missing `new_state` parameter.'}), 400) try: new_state = int(request.form['new_state']) except (ValueError, KeyError): return make_response(jsonify({'error': 'Invalid `new_state` parameter.'}), 400) route_value = valid_routes[route_key] with DBManager.create_session_scope() as db_session: row = db_session.query(route_value).filter_by(id=row_id).one_or_none() if row: validator = route_validator.get(route_key, None) if validator is not None: res = validator(row) if not res: return make_response(jsonify({'error': 'cannot modify {}'.format(route_key)}), 400) row.enabled = True if new_state == 1 else False db_session.commit() payload = { '{}_id'.format(route_key): row.id, # remove this 'id': row.id, 'new_state': row.enabled, } AdminLogManager.post('{title} toggled'.format(title=route_title[route_key]), options['user'], 'Enabled' if row.enabled else 'Disabled', route_name[route_key](row)) SocketClientManager.send('{}.update'.format(route_key), payload) return make_response(jsonify({'success': 'successful toggle', 'new_state': new_state})) else: return make_response(jsonify({'error': 'invalid {} id'.format(route_key)}))
def timer_remove(timer_id, **options): with DBManager.create_session_scope() as db_session: timer = db_session.query(Timer).filter_by(id=timer_id).one_or_none() if timer is None: return make_response(jsonify({'error': 'Invalid timer ID'})) db_session.delete(timer) SocketClientManager.send('timer.remove', {'timer_id': timer.id}) return make_response(jsonify({'success': 'good job'}))
def banphrases(**options): with DBManager.create_session_scope() as db_session: banphrases = db_session.query(Banphrase).options( joinedload(Banphrase.data).joinedload(BanphraseData.user), joinedload(Banphrase.data).joinedload( BanphraseData.user2)).all() return render_template('admin/banphrases.html', banphrases=banphrases)
def decks_warlock(): session = DBManager.create_session() decks = session.query(Deck).filter_by(deck_class='warlock').order_by( Deck.last_used.desc(), Deck.first_used.desc()).all() session.close() return render_template('decks/by_class.html', decks=decks, deck_class='Warlock')
def pleblist_blacklist(): with DBManager.create_session_scope() as session: current_stream = session.query(Stream).filter_by(ended=False).order_by(Stream.stream_start).first() if current_stream is None: return make_response(jsonify({'error': 'Stream offline'}), 400) # TODO: implement this return make_response(jsonify({'error': 'NOT IMPLEMENTED'}), 400)
def get(self, stream_id): with DBManager.create_session_scope() as session: songs = session.query(PleblistSong).filter_by(stream_id=stream_id) return pajbot.web.utils.jsonify_list( 'songs', songs, base_url=url_for(self.endpoint, stream_id=stream_id, _external=True), )
def timers_edit(timer_id, **options): with DBManager.create_session_scope() as db_session: timer = db_session.query(Timer).filter_by( id=timer_id).one_or_none() if timer is None: return render_template('admin/timer_404.html'), 404 return render_template('admin/create_timer.html', timer=timer)
def get(self, timer_id, **options): with DBManager.create_session_scope() as db_session: timer = db_session.query(Timer).filter_by(id=timer_id).one_or_none() if timer is None: return {'error': 'Invalid timer ID'}, 404 AdminLogManager.post('Timer removed', options['user'], timer.name) db_session.delete(timer) SocketClientManager.send('timer.remove', {'id': timer.id}) return {'success': 'good job'}
def __init__(self, bot): self.bot = bot self.banphrases = [] self.enabled_banphrases = [] self.db_session = DBManager.create_session(expire_on_commit=False) if self.bot: self.bot.socket_manager.add_handler('banphrase.update', self.on_banphrase_update) self.bot.socket_manager.add_handler('banphrase.remove', self.on_banphrase_remove)
def remove_highlight(self, id): """ Returns True if a highlight was removed, otherwise return False """ with DBManager.create_session_scope() as db_session: num_rows = db_session.query(StreamChunkHighlight).filter(StreamChunkHighlight.id == id).delete() return (num_rows == 1)
def remove_command(self, command): self.remove_command_aliases(command) with DBManager.create_session_scope() as db_session: self.db_session.expunge(command.data) db_session.delete(command.data) db_session.delete(command) self.rebuild()
def timers_create(**options): session.pop('timer_created_id', None) session.pop('timer_edited_id', None) if request.method == 'POST': id = None try: if 'id' in request.form: id = int(request.form['id']) name = request.form['name'].strip() interval_online = int(request.form['interval_online']) interval_offline = int(request.form['interval_offline']) message_type = request.form['message_type'] message = request.form['message'].strip() except (KeyError, ValueError): abort(403) if interval_online < 0 or interval_offline < 0: abort(403) if message_type not in ['say', 'me']: abort(403) if len(message) == 0: abort(403) options = { 'name': name, 'interval_online': interval_online, 'interval_offline': interval_offline, } action = { 'type': message_type, 'message': message } options['action'] = action if id is None: timer = Timer(**options) with DBManager.create_session_scope(expire_on_commit=False) as db_session: if id is not None: timer = db_session.query(Timer).filter_by(id=id).one_or_none() if timer is None: return redirect('/admin/timers/', 303) timer.set(**options) else: db_session.add(timer) SocketClientManager.send('timer.update', {'timer_id': timer.id}) if id is None: session['timer_created_id'] = timer.id else: session['timer_edited_id'] = timer.id return redirect('/admin/timers/', 303) else: return render_template('admin/create_timer.html')
def decks(): session = DBManager.create_session() top_decks = [] for deck in session.query(Deck).order_by(Deck.last_used.desc(), Deck.first_used.desc())[:25]: top_decks.append(deck) session.close() return render_template('decks/all.html', top_decks=top_decks, deck_class=None)
def timers_edit(timer_id, **options): with DBManager.create_session_scope() as db_session: timer = db_session.query(Timer).filter_by(id=timer_id).one_or_none() if timer is None: return render_template('admin/timer_404.html'), 404 return render_template('admin/create_timer.html', timer=timer)
def banphrases_edit(banphrase_id, **options): with DBManager.create_session_scope() as db_session: banphrase = db_session.query(Banphrase).filter_by(id=banphrase_id).one_or_none() if banphrase is None: return render_template('admin/banphrase_404.html'), 404 return render_template('admin/create_banphrase.html', banphrase=banphrase)
def load_config(self, config): self.config = config self.nickname = config['main'].get('nickname', 'pajbot') self.password = config['main'].get('password', 'abcdef') self.timezone = config['main'].get('timezone', 'UTC') self.trusted_mods = config.getboolean('main', 'trusted_mods') TimeManager.init_timezone(self.timezone) if 'streamer' in config['main']: self.streamer = config['main']['streamer'] self.channel = '#' + self.streamer elif 'target' in config['main']: self.channel = config['main']['target'] self.streamer = self.channel[1:] self.wolfram = None try: if 'wolfram' in config['main']: import wolframalpha self.wolfram = wolframalpha.Client(config['main']['wolfram']) except: pass self.silent = False self.dev = False if 'flags' in config: self.silent = True if 'silent' in config['flags'] and config[ 'flags']['silent'] == '1' else self.silent self.dev = True if 'dev' in config['flags'] and config['flags'][ 'dev'] == '1' else self.dev DBManager.init(self.config['main']['db']) redis_options = {} if 'redis' in config: log.info(config._sections['redis']) redis_options = config._sections['redis'] RedisManager.init(**redis_options)
def timers_create(**options): session.pop('timer_created_id', None) session.pop('timer_edited_id', None) if request.method == 'POST': id = None try: if 'id' in request.form: id = int(request.form['id']) name = request.form['name'].strip() interval_online = int(request.form['interval_online']) interval_offline = int(request.form['interval_offline']) message_type = request.form['message_type'] message = request.form['message'].strip() except (KeyError, ValueError): abort(403) if interval_online < 0 or interval_offline < 0: abort(403) if message_type not in ['say', 'me']: abort(403) if len(message) == 0: abort(403) options = { 'name': name, 'interval_online': interval_online, 'interval_offline': interval_offline, } action = {'type': message_type, 'message': message} options['action'] = action if id is None: timer = Timer(**options) with DBManager.create_session_scope( expire_on_commit=False) as db_session: if id is not None: timer = db_session.query(Timer).filter_by( id=id).one_or_none() if timer is None: return redirect('/admin/timers/', 303) timer.set(**options) else: db_session.add(timer) SocketClientManager.send('timer.update', {'timer_id': timer.id}) if id is None: session['timer_created_id'] = timer.id else: session['timer_edited_id'] = timer.id return redirect('/admin/timers/', 303) else: return render_template('admin/create_timer.html')
def reload(self): # TODO: Make disable/enable better, so we don't need to disable modules # that we're just going to enable again further down below. for module in self.modules: log.debug('Disabling {module.NAME}'.format(module=module)) module.disable(self.bot) self.modules = [] with DBManager.create_session_scope() as db_session: for enabled_module in db_session.query(Module).filter_by( enabled=True): module = find(lambda m: m.ID == enabled_module.id, self.all_modules) if module is not None: options = {} if enabled_module.settings is not None: try: options['settings'] = json.loads( enabled_module.settings) except ValueError: log.warn('Invalid JSON') self.modules.append(module.load(**options)) log.debug('Enabling {module.NAME}'.format(module=module)) module.enable(self.bot) to_be_removed = [] self.modules.sort( key=lambda m: 1 if m.PARENT_MODULE is not None else 0) for module in self.modules: if module.PARENT_MODULE is None: module.submodules = [] else: parent = find(lambda m: m.__class__ == module.PARENT_MODULE, self.modules) if parent is not None: parent.submodules.append(module) module.parent_module = parent else: log.warn( 'Missing parent for module {}, disabling it.'.format( module.NAME)) module.parent_module = None to_be_removed.append(module) for module in to_be_removed: log.debug('Disabling (2) {module.NAME}'.format(module=module)) module.disable(self.bot) self.modules.remove(module) # Perform a last on_loaded call on each module. # This is used for things that require submodules to be loaded properly # i.e. the quest system for module in self.modules: module.on_loaded()
def follow_user(self, username): """Add `username` to our relevant_users list.""" if self.listener: if username not in self.listener.relevant_users: with DBManager.create_session_scope() as db_session: db_session.add(TwitterUser(username)) self.listener.relevant_users.append(username) log.info('Now following {0}'.format(username)) return True return False
def pleblist_blacklist(): with DBManager.create_session_scope() as session: current_stream = session.query(Stream).filter_by(ended=False).order_by( Stream.stream_start).first() if current_stream is None: return make_response(jsonify({'error': 'Stream offline'}), 400) # TODO: implement this return make_response(jsonify({'error': 'NOT IMPLEMENTED'}), 400)
def remove_highlight(self, id): """ Returns True if a highlight was removed, otherwise return False """ with DBManager.create_session_scope() as db_session: num_rows = db_session.query(StreamChunkHighlight).filter( StreamChunkHighlight.id == id).delete() return (num_rows == 1)
def get(self, banphrase_id, **options): with DBManager.create_session_scope() as db_session: banphrase = db_session.query(Banphrase).filter_by(id=banphrase_id).one_or_none() if banphrase is None: return {'error': 'Invalid banphrase ID'}, 404 AdminLogManager.post('Banphrase removed', options['user'], banphrase.phrase) db_session.delete(banphrase) db_session.delete(banphrase.data) SocketClientManager.send('banphrase.remove', {'id': banphrase.id}) return {'success': 'good job'}, 200
def enable(self, bot): HandlerManager.add_handler('on_message', self.on_message, priority=200) HandlerManager.add_handler('on_commit', self.on_commit) if self.db_session is not None: self.db_session.commit() self.db_session.close() self.db_session = None self.links = {} self.db_session = DBManager.create_session()
def banphrases_edit(banphrase_id, **options): with DBManager.create_session_scope() as db_session: banphrase = db_session.query(Banphrase).filter_by( id=banphrase_id).one_or_none() if banphrase is None: return render_template('admin/banphrase_404.html'), 404 return render_template('admin/create_banphrase.html', banphrase=banphrase)
def get_current_song(stream_id): with DBManager.create_session_scope() as session: cur_song = session.query(PleblistSong).filter( PleblistSong.stream_id == stream_id, PleblistSong.date_played.is_(None)).order_by( PleblistSong.date_added.asc(), PleblistSong.id.asc()).first() if cur_song is None: return None session.expunge(cur_song) return cur_song
def pleblist_list_by_stream(stream_id): with DBManager.create_session_scope() as session: songs = session.query(PleblistSong).filter_by( stream_id=stream_id).all() payload = { '_total': len(songs), 'songs': [song.jsonify() for song in songs], } return jsonify(payload)
def highlight_id(date, highlight_id, highlight_title=None): with DBManager.create_session_scope() as db_session: highlight = db_session.query(StreamChunkHighlight).options(joinedload('*')).filter_by(id=highlight_id).first() if highlight is None: return render_template('highlight_404.html'), 404 else: stream_chunk = highlight.stream_chunk stream = stream_chunk.stream return render_template('highlight.html', highlight=highlight, stream_chunk=stream_chunk, stream=stream)
def commands_edit(command_id, **options): with DBManager.create_session_scope() as db_session: command = db_session.query(Command).options( joinedload(Command.data).joinedload( CommandData.user)).filter_by(id=command_id).one_or_none() if command is None: return render_template('admin/command_404.html'), 404 return render_template('admin/edit_command.html', command=command, user=options.get('user', None))
def banphrase_remove(banphrase_id, **options): with DBManager.create_session_scope() as db_session: banphrase = db_session.query(Banphrase).filter_by( id=banphrase_id).one_or_none() if banphrase is None: return make_response(jsonify({'error': 'Invalid banphrase ID'})) AdminLogManager.post('Banphrase removed', options['user'], banphrase.phrase) db_session.delete(banphrase) db_session.delete(banphrase.data) SocketClientManager.send('banphrase.remove', {'banphrase_id': banphrase.id}) return make_response(jsonify({'success': 'good job'}))