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 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 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 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 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 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 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 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 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 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 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 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 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 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 __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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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_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 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 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 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 predictions(**options): with DBManager.create_session_scope() as db_session: predictions = db_session.query(PredictionRun).order_by(PredictionRun.started.desc()).all() for prediction in predictions: prediction.num_entries = db_session.query(PredictionRunEntry).filter_by(prediction_run_id=prediction.id).count() pass return render_template('admin/predictions.html', predictions=predictions)
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 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 get_highlight_thumbnails(no_clue_what_this_does): from pajbot.web.models.thumbnail import StreamThumbnailWriter with DBManager.create_session_scope() as db_session: highlights = db_session.query(StreamChunkHighlight).filter_by(thumbnail=None).all() if len(highlights) > 0: log.info('Writing {} thumbnails...'.format(len(highlights))) StreamThumbnailWriter(app.bot_config['main']['streamer'], [h.id for h in highlights]) log.info('Done!') for highlight in highlights: highlight.thumbnail = True
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 moderators(**options): with DBManager.create_session_scope() as db_session: moderator_users = db_session.query(User).filter(User.level > 100).order_by(User.level.desc()).all() userlists = collections.OrderedDict() userlists['Admins'] = list(filter(lambda user: user.level >= 2000, moderator_users)) userlists['Super Moderators/Broadcaster'] = list(filter(lambda user: user.level >= 1000 and user.level < 2000, moderator_users)) userlists['Moderators'] = list(filter(lambda user: user.level >= 500 and user.level < 1000, moderator_users)) userlists['Notables/Helpers'] = list(filter(lambda user: user.level >= 101 and user.level < 500, moderator_users)) return render_template('admin/moderators.html', userlists=userlists)
def shared_close_predict(self, bot, source, type): with DBManager.create_session_scope() as db_session: # Check if there is a non-ended, but closed prediction run we can end current_prediction_run = db_session.query(PredictionRun).filter_by(ended=None, open=True, type=type).one_or_none() if current_prediction_run is None: bot.say('{}, There is no open prediction runs we can close right now.'.format(source.username_raw)) return True current_prediction_run.open = False bot.say('{}, Predictions are no longer accepted for prediction run {}'.format(source.username_raw, current_prediction_run.id))
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 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 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 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 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 predictions(**options): with DBManager.create_session_scope() as db_session: predictions = db_session.query(PredictionRun).order_by( PredictionRun.started.desc()).all() for prediction in predictions: prediction.num_entries = db_session.query( PredictionRunEntry).filter_by( prediction_run_id=prediction.id).count() pass return render_template('admin/predictions.html', predictions=predictions)
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'}))
def modules(**options): module_manager = ModuleManager(None).load(do_reload=False) 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 return render_template('admin/modules.html', modules=module_manager.all_modules)
def get_highlight_thumbnails(no_clue_what_this_does): from pajbot.web.models.thumbnail import StreamThumbnailWriter with DBManager.create_session_scope() as db_session: highlights = db_session.query(StreamChunkHighlight).filter_by( thumbnail=None).all() if len(highlights) > 0: log.info('Writing {} thumbnails...'.format( len(highlights))) StreamThumbnailWriter(app.bot_config['main']['streamer'], [h.id for h in highlights]) log.info('Done!') for highlight in highlights: highlight.thumbnail = True
def on_timer_update(self, data, conn): try: timer_id = int(data['timer_id']) except (KeyError, ValueError): log.warn('No timer ID found in on_timer_update') return False updated_timer = find(lambda timer: timer.id == timer_id, self.timers) if updated_timer: with DBManager.create_session_scope( expire_on_commit=False) as db_session: db_session.add(updated_timer) db_session.refresh(updated_timer) updated_timer.refresh_action() db_session.expunge(updated_timer) else: with DBManager.create_session_scope( expire_on_commit=False) as db_session: updated_timer = db_session.query(Timer).filter_by( id=timer_id).one_or_none() # Add the updated timer to the timer lists if required if updated_timer: if updated_timer not in self.timers: self.timers.append(updated_timer) if updated_timer not in self.online_timers and updated_timer.interval_online > 0: self.online_timers.append(updated_timer) updated_timer.refresh_tts() if updated_timer not in self.offline_timers and updated_timer.interval_offline > 0: self.offline_timers.append(updated_timer) updated_timer.refresh_tts() for timer in self.online_timers: if timer.enabled is False or timer.interval_online <= 0: self.online_timers.remove(timer) for timer in self.offline_timers: if timer.enabled is False or timer.interval_offline <= 0: self.offline_timers.remove(timer)
def stats(): top_5_commands = sorted(app.bot_commands_list, key=lambda c: c.data.num_uses if c.data is not None else -1, reverse=True)[:5] # TODO: Make this hideable through some magic setting (NOT config.ini @_@) with DBManager.create_session_scope() as db_session: top_5_line_farmers = db_session.query(User).order_by( User.num_lines.desc())[:5] return render_template('stats.html', top_5_commands=top_5_commands, top_5_line_farmers=top_5_line_farmers)
def pleblist_history_redirect(): with DBManager.create_session_scope() as session: current_stream = session.query(Stream).filter_by( ended=False).order_by(Stream.stream_start.desc()).first() if current_stream is not None: return redirect( '/pleblist/history/{}/'.format(current_stream.id), 303) last_stream = session.query(Stream).filter_by(ended=True).order_by( Stream.stream_start.desc()).first() if last_stream is not None: return redirect('/pleblist/history/{}/'.format(last_stream.id), 303) return render_template('pleblist_history_no_stream.html'), 404
def shared_close_predict(self, bot, source, type): with DBManager.create_session_scope() as db_session: # Check if there is a non-ended, but closed prediction run we can end current_prediction_run = db_session.query(PredictionRun).filter_by( ended=None, open=True, type=type).one_or_none() if current_prediction_run is None: bot.say( '{}, There is no open prediction runs we can close right now.' .format(source.username_raw)) return True current_prediction_run.open = False bot.say( '{}, Predictions are no longer accepted for prediction run {}'. format(source.username_raw, current_prediction_run.id))