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 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 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 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 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 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_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 __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 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'}))
