def add_banphrase(self, **options):
"""Method for creating and editing banphrases.
Usage: !add banphrase BANPHRASE [options]
Multiple options available:
--length LENGTH
--perma/--no-perma
--notify/--no-notify
"""
message = options['message']
bot = options['bot']
source = options['source']
if message:
options, phrase = bot.banphrase_manager.parse_banphrase_arguments(message)
if options is False:
bot.whisper(source.username, 'Invalid banphrase')
return False
options['added_by'] = source.id
options['edited_by'] = source.id
banphrase, new_banphrase = bot.banphrase_manager.create_banphrase(phrase, **options)
if new_banphrase is True:
bot.whisper(source.username, 'Added your banphrase (ID: {banphrase.id})'.format(banphrase=banphrase))
return True
banphrase.set(**options)
banphrase.data.set(edited_by=options['edited_by'])
DBManager.session_add_expunge(banphrase)
bot.banphrase_manager.commit()
bot.whisper(source.username, 'Updated your banphrase (ID: {banphrase.id}) with ({what})'.format(banphrase=banphrase, what=', '.join([key for key in options if key != 'added_by'])))
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)
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
db_session.expunge_all()
db_session.close()
self.current_stream.stream_chunks.append(stream_chunk)
def add_banphrase(bot, source, message, event, args):
"""Dispatch method for creating and editing banphrases.
Usage: !add banphrase BANPHRASE [options]
Multiple options available:
--length LENGTH
--perma/--no-perma
--notify/--no-notify
"""
if message:
options, phrase = bot.banphrase_manager.parse_banphrase_arguments(message)
if options is False:
bot.whisper(source.username, 'Invalid banphrase')
return False
options['added_by'] = source.id
banphrase, new_banphrase = bot.banphrase_manager.create_banphrase(phrase, **options)
if new_banphrase is True:
bot.whisper(source.username, 'Added your banphrase (ID: {banphrase.id})'.format(banphrase=banphrase))
return True
banphrase.set(**options)
DBManager.session_add_expunge(banphrase)
bot.whisper(source.username, 'Updated your banphrase (ID: {banphrase.id}) with ({what})'.format(banphrase=banphrase, what=', '.join([key for key in options])))
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 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
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
with DBManager.create_session_scope() as db_session:
db_module = db_session.query(Module).filter_by(
id=module_id).one_or_none()
if db_module is None:
return render_template('admin/module_404.html'), 404
db_module.settings = json.dumps(res)
db_session.commit()
current_module.db_module = db_module
settings = None
try:
settings = json.loads(db_module.settings)
except (TypeError, ValueError):
pass
current_module.load(settings=settings)
SocketClientManager.send('module.update',
{'module_id': db_module.id})
return render_template('admin/configure_module.html',
module=current_module)
pass
else:
with DBManager.create_session_scope() as db_session:
db_module = db_session.query(Module).filter_by(
id=module_id).one_or_none()
if db_module is None:
return render_template('admin/module_404.html'), 404
current_module.db_module = db_module
settings = None
try:
settings = json.loads(db_module.settings)
except (TypeError, ValueError):
pass
current_module.load(settings=settings)
return render_template('admin/configure_module.html',
module=current_module)
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
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
with DBManager.create_session_scope() as db_session:
db_module = db_session.query(Module).filter_by(id=module_id).one_or_none()
if db_module is None:
return render_template('admin/module_404.html'), 404
db_module.settings = json.dumps(res)
db_session.commit()
current_module.db_module = db_module
settings = None
try:
settings = json.loads(db_module.settings)
except (TypeError, ValueError):
pass
current_module.load(settings=settings)
SocketClientManager.send('module.update', {'module_id': db_module.id})
return render_template('admin/configure_module.html',
module=current_module)
pass
else:
with DBManager.create_session_scope() as db_session:
db_module = db_session.query(Module).filter_by(id=module_id).one_or_none()
if db_module is None:
return render_template('admin/module_404.html'), 404
current_module.db_module = db_module
settings = None
try:
settings = json.loads(db_module.settings)
except (TypeError, ValueError):
pass
current_module.load(settings=settings)
return render_template('admin/configure_module.html',
module=current_module)
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 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 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 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)
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 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()
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()
if stream is None:
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()
log.info('Successfully created a stream')
def generic_toggle(route_key, row_id, **options):
valid_routes = {
'timer': Timer,
'banphrase': Banphrase,
'module': Module,
}
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:
row.enabled = True if new_state == 1 else False
db_session.commit()
SocketClientManager.send('{}.update'.format(route_key), {'{}_id'.format(route_key): row.id})
return make_response(jsonify({'success': 'successful toggle', 'new_state': new_state}))
else:
return make_response(jsonify({'error': 'invalid {} id'.format(route_key)}))
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 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
if bot:
bot.add_handler('on_message', self.on_message, priority=100)
bot.add_handler('on_commit', self.on_commit)
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 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 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()
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()
if stream is None:
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()
log.info('Successfully created a stream')
def __init__(self, bot):
self.bot = bot
self.db_session = DBManager.create_session()
self.twitter_client = None
self.twitter_stream = None
self.listener = None
if 'twitter' in bot.config:
self.use_twitter_stream = 'streaming' in bot.config[
'twitter'] and bot.config['twitter']['streaming'] == '1'
try:
self.twitter_auth = tweepy.OAuthHandler(
bot.config['twitter']['consumer_key'],
bot.config['twitter']['consumer_secret'])
self.twitter_auth.set_access_token(
bot.config['twitter']['access_token'],
bot.config['twitter']['access_token_secret'])
self.twitter_client = tweepy.API(self.twitter_auth)
if self.use_twitter_stream:
self.connect_to_twitter_stream()
bot.execute_every(60 * 5, self.check_twitter_connection)
except:
log.exception('Twitter authentication failed.')
self.twitter_client = None
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.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 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)
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,
}
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:
row.enabled = True if new_state == 1 else False
db_session.commit()
SocketClientManager.send('{}.update'.format(route_key), {'{}_id'.format(route_key): row.id})
return make_response(jsonify({'success': 'successful toggle', 'new_state': new_state}))
else:
return make_response(jsonify({'error': 'invalid {} id'.format(route_key)}))
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 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
if bot:
bot.add_handler('on_message', self.on_message, priority=100)
bot.add_handler('on_commit', self.on_commit)
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 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 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:
moderator_users = db_session.query(User).filter(User.level > 100).order_by(User.id.desc()).all()
return render_template(
'admin/commands.html',
moderator_users=moderator_users,
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 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 pleblist_validate():
if not request.method == "POST":
return make_response(jsonify({"error": "Invalid request method"}), 405)
if "youtube_id" not in request.form:
return make_response(jsonify({"error": "Missing data youtube_id"}), 400)
with DBManager.create_session_scope() as session:
youtube_id = request.form["youtube_id"]
print(youtube_id)
song_info = session.query(PleblistSongInfo).filter_by(pleblist_song_youtube_id=youtube_id).first()
if song_info is not None:
return jsonify({"message": "success", "song_info": song_info.jsonify()})
PleblistManager.init(config["youtube"]["developer_key"])
song_info = PleblistManager.create_pleblist_song_info(youtube_id)
if not song_info and len(youtube_id) > 11:
youtube_id = youtube_id[:11]
song_info = session.query(PleblistSongInfo).filter_by(pleblist_song_youtube_id=youtube_id).first()
if song_info is not None:
return jsonify({"message": "success", "new_youtube_id": youtube_id, "song_info": song_info.jsonify()})
else:
song_info = PleblistManager.create_pleblist_song_info(youtube_id)
if song_info:
print(song_info)
session.add(song_info)
session.commit()
return jsonify({"message": "success", "new_youtube_id": youtube_id, "song_info": song_info.jsonify()})
return jsonify({"message": "invalid youtube id", "song_info": 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 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 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 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)
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 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 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 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 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 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"}))
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_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)
SocketClientManager.send(
'module.update', {'module_id': current_module.db_module.id})
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 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 __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 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'}))
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 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 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'}))
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 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 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 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 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(config['main']['streamer'], [h.id for h in highlights])
log.info('Done!')
for highlight in highlights:
highlight.thumbnail = True
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 commands_edit(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 render_template('admin/command_404.html'), 404
return render_template('admin/edit_command.html',
command=command,
user=options.get('user', None))
