def create_stream_chunk(self, status):
if self.current_stream_chunk is not None:
# There's already a stream chunk started!
session = DBManager.create_session(expire_on_commit=False)
self.current_stream_chunk.chunk_end = datetime.datetime.now()
session.add(self.current_stream_chunk)
session.commit()
session.close()
self.current_stream_chunk = None
session = DBManager.create_session(expire_on_commit=False)
stream_chunk = 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
session.add(stream_chunk)
session.commit()
else:
log.info('We already have a stream chunk!')
self.current_stream_chunk = stream_chunk
session.expunge_all()
session.close()
self.current_stream.stream_chunks.append(stream_chunk)
def highlight_list_date(date):
# Make sure we were passed a valid date
try:
parsed_date = datetime.datetime.strptime(date, '%Y-%m-%d')
except ValueError:
# Invalid date
return redirect('/highlights/', 303)
session = DBManager.create_session()
dates_with_highlights = []
highlights = session.query(StreamChunkHighlight).filter(
cast(StreamChunkHighlight.created_at, Date) == parsed_date).order_by(
StreamChunkHighlight.created_at.desc()).all()
for highlight in session.query(StreamChunkHighlight):
dates_with_highlights.append(
datetime.datetime(year=highlight.created_at.year,
month=highlight.created_at.month,
day=highlight.created_at.day))
try:
return render_template(
'highlights_date.html',
highlights=highlights,
date=parsed_date,
dates_with_highlights=set(dates_with_highlights))
finally:
session.close()
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()).first()
if cur_song is None:
return None
session.expunge(cur_song)
return cur_song
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_highlight(self, **options):
"""
Returns an error message (string) if something went wrong, otherwise returns True
"""
if self.online is False or self.current_stream_chunk is None:
return 'The stream is not online'
if self.current_stream_chunk.video_url is None:
return 'No video URL fetched for this chunk yet, try in 5 minutes'
try:
highlight = StreamChunkHighlight(self.current_stream_chunk, **options)
session = DBManager.create_session(expire_on_commit=False)
session.add(highlight)
session.add(self.current_stream_chunk)
session.commit()
session.close()
x = inspect(self.current_stream_chunk)
log.info('{0.transient} - {0.pending} - {0.persistent} - {0.detached}'.format(x))
x = inspect(highlight)
log.info('{0.transient} - {0.pending} - {0.persistent} - {0.detached}'.format(x))
x = inspect(self.current_stream)
log.info('{0.transient} - {0.pending} - {0.persistent} - {0.detached}'.format(x))
log.info(self.current_stream.id)
log.info(highlight.id)
log.info(self.current_stream_chunk.id)
except:
log.exception('uncaught exception in create_highlight')
return 'Unknown reason, ask pajlada'
return True
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 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)
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.
"""
session = DBManager.create_session(expire_on_commit=False)
self.current_stream = session.query(Stream).filter_by(ended=False).order_by(Stream.stream_start.desc()).first()
self.last_stream = session.query(Stream).filter_by(ended=True).order_by(Stream.stream_end.desc()).first()
# if self.current_stream and len(self.current_stream.stream_chunks) > 0:
if self.current_stream:
# sorted_chunks = sorted(self.current_stream.stream_chunks, key=lambda x: x.chunk_start, reverse=True)
# self.current_stream_chunk = sorted_chunks[0]
self.current_stream_chunk = 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))
session.expunge_all()
session.close()
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 create_command(self, alias_str, **options):
"""
TODO: Does this part of the code work as expected?
Right now if the second alias is already used, it could result in us
creating a command with an alias that's already in use.
"""
aliases = alias_str.lower().replace('!', '').split('|')
main_alias = aliases[0]
if main_alias in self.data:
# Command with this alias already exists, return its instance!
return self.data[main_alias], False
command = Command(command=alias_str, **options)
command.data = CommandData(command.id)
self.add_command_aliases(command)
with DBManager.create_session_scope(
expire_on_commit=False) as db_session:
db_session.add(command)
db_session.add(command.data)
db_session.commit()
db_session.expunge(command)
db_session.expunge(command.data)
self.db_session.add(command.data)
self.commit()
return command, True
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 stats_duels():
session = DBManager.create_session()
data = {
'top_5_winners':
session.query(UserDuelStats).order_by(
UserDuelStats.duels_won.desc())[:5],
'top_5_points_won':
session.query(UserDuelStats).order_by(UserDuelStats.profit.desc())[:5],
'top_5_points_lost':
session.query(UserDuelStats).order_by(UserDuelStats.profit.asc())[:5],
'top_5_losers':
session.query(UserDuelStats).order_by(
UserDuelStats.duels_lost.desc())[:5],
'top_5_winrate':
session.query(UserDuelStats).filter(
UserDuelStats.duels_won >= 5).order_by(
UserDuelStats.winrate.desc())[:5],
'bottom_5_winrate':
session.query(UserDuelStats).filter(
UserDuelStats.duels_lost >= 5).order_by(
UserDuelStats.winrate.asc())[:5],
}
try:
return render_template('stats_duels.html', **data)
finally:
session.close()
def command_checkalias(**options):
if 'alias' not in request.form:
return make_response(jsonify({'error': 'Missing `alias` parameter.'}),
400)
request_alias = request.form['alias'].lower()
command_manager = CommandManager(None)
internal_commands = command_manager.get_internal_commands()
db_command_aliases = []
with DBManager.create_session_scope() as db_session:
for command in db_session.query(Command):
db_command_aliases.extend(command.command.split('|'))
for alias in internal_commands:
db_command_aliases.append(alias)
db_command_aliases = set(db_command_aliases)
if request_alias in db_command_aliases:
return make_response(jsonify({'error': 'Alias already in use'}))
else:
return make_response(jsonify({'success': 'good job'}))
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
if self.current_stream_chunk.video_url is not None:
return
log.info('Attempting to fetch video url for broadcast {0}'.format(self.current_stream_chunk.broadcast_id))
video_url, video_preview_image_url = self.fetch_video_url(self.current_stream_chunk)
if video_url is not None:
log.info('Successfully fetched a video url: {0}'.format(video_url))
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 it and shit')
else:
log.info('Not video for broadcast found')
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('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('added shit to current_stream etc')
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 pleblist_add():
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)
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:
youtube_id = request.form['youtube_id']
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)
song_requested = PleblistSong(current_stream.id, youtube_id)
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(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 jsonify({'success': True})
def __init__(self, bot):
self.db_session = DBManager.create_session()
self.messages = []
self.bot = bot
self.minute = 0
self.iterator = 0
self.bot.execute_every(60, self.tick)
def points():
session = DBManager.create_session()
top_30_users = []
for user in session.query(User).order_by(User.points.desc())[:30]:
top_30_users.append(user)
session.close()
return render_template('points.html',
top_30_users=top_30_users)
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 __init__(self, bot):
self.db_session = DBManager.create_session()
self.messages = []
self.bot = bot
self.minute = 0
self.iterator = 0
self.bot.execute_every(60, self.tick)
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_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 __init__(self, bot):
UserDict.__init__(self)
self.bot = bot
self.streamer = bot.streamer
self.db_session = DBManager.create_session()
self.custom_data = []
self.bttv_emote_manager = BTTVEmoteManager(self)
self.bot.execute_every(60 * 60 * 2, self.bot.action_queue.add, (self.bttv_emote_manager.update_emotes, ))
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 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 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 highlights():
session = DBManager.create_session()
streams = session.query(Stream).order_by(Stream.stream_start.desc()).all()
for stream in streams:
stream.stream_chunks = sorted(stream.stream_chunks, key=lambda x: x.chunk_start, reverse=True)
for stream_chunk in stream.stream_chunks:
stream_chunk.highlights = sorted(stream_chunk.highlights, key=lambda x: x.created_at, reverse=True)
session.close()
return render_template('highlights.html',
streams=streams)
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):
UserDict.__init__(self)
self.db_session = DBManager.create_session()
self.internal_commands = None
self.bot = bot
if bot:
self.bot.socket_manager.add_handler('command.update',
self.on_command_update)
self.bot.socket_manager.add_handler('command.remove',
self.on_command_remove)
def __init__(self, bot):
UserDict.__init__(self)
self.bot = bot
self.streamer = bot.streamer
self.db_session = DBManager.create_session()
self.custom_data = []
self.bttv_emote_manager = BTTVEmoteManager(self)
self.bot.execute_every(60 * 60 * 2, self.bot.action_queue.add,
(self.bttv_emote_manager.update_emotes, ))
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 remove_highlight(self, id):
"""
Returns True if a highlight was removed, otherwise return False
"""
session = DBManager.create_session()
num_rows = session.query(StreamChunkHighlight).filter(StreamChunkHighlight.id == id).delete()
session.commit()
session.close()
return (num_rows == 1)
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 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))
def update_highlight(self, id, **options):
"""
Returns True if a highlight was modified, otherwise return False
"""
if 'offset' in options:
options['highlight_offset'] = options.pop('offset')
with DBManager.create_session_scope() as db_session:
num_rows = db_session.query(StreamChunkHighlight).filter(StreamChunkHighlight.id == id).update(options)
return (num_rows == 1)
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 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
songs = session.query(PleblistSong).filter(PleblistSong.stream_id == stream.id).order_by(PleblistSong.date_added.asc(), PleblistSong.date_played.asc()).all()
total_length_left = sum([song.song_info.duration if song.date_played is None and song.song_info is not None else 0 for song in songs])
return render_template('pleblist_history.html',
stream=stream,
songs=songs,
total_length_left=total_length_left)
def pleblist_list():
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)
songs = session.query(PleblistSong).filter(PleblistSong.stream_id == current_stream.id, PleblistSong.date_played.is_(None)).all()
payload = {
'_total': len(songs),
'songs': [song.jsonify() for song in songs],
}
return jsonify(payload)
def __init__(self, reactor, bot, target, message_limit, time_interval, num_of_conns=30):
self.db_session = DBManager.create_session()
self.reactor = reactor
self.bot = bot
self.message_limit = message_limit
self.time_interval = time_interval
self.num_of_conns = num_of_conns
self.whisper_thread = None
self.connlist = []
self.whispers = Queue()
self.maintenance_lock = False
def stats():
top_5_commands = sorted(bot_commands_list, key=lambda c: c.num_uses, reverse=True)[:5]
if 'linefarming' in modules:
session = DBManager.create_session()
top_5_line_farmers = session.query(User).order_by(User.num_lines.desc())[:5]
session.close()
else:
top_5_line_farmers = []
return render_template('stats.html',
top_5_commands=top_5_commands,
top_5_line_farmers=top_5_line_farmers)
def points():
custom_content = custom_web_content.get('points', '')
try:
custom_content = Markup(markdown.markdown(custom_content))
except:
log.exception('Unhandled exception in def index')
session = DBManager.create_session()
top_30_users = []
for user in session.query(User).order_by(User.points.desc())[:30]:
top_30_users.append(user)
session.close()
return render_template('points.html',
top_30_users=top_30_users,
custom_content=custom_content)
def update_highlight(self, id, **options):
"""
Returns True if a highlight was modified, otherwise return False
"""
if 'offset' in options:
options['highlight_offset'] = options.pop('offset')
session = DBManager.create_session()
num_rows = session.query(StreamChunkHighlight).filter(StreamChunkHighlight.id == id).update(options)
session.commit()
session.close()
return (num_rows == 1)
def highlight_id(date, highlight_id, highlight_title=None):
session = DBManager.create_session()
highlight = session.query(StreamChunkHighlight).filter_by(id=highlight_id).first()
if highlight is None:
session.close()
return render_template('highlight_404.html'), 404
else:
stream_chunk = highlight.stream_chunk
stream = stream_chunk.stream
session.close()
return render_template('highlight.html',
highlight=highlight,
stream_chunk=stream_chunk,
stream=stream)
def __init__(self, bot, run_later):
self.db_session = DBManager.create_session()
self.blacklisted_links = []
self.whitelisted_links = []
if 'safebrowsingapi' in bot.config['main']:
self.safeBrowsingAPI = SafeBrowsingAPI(bot.config['main']['safebrowsingapi'], bot.nickname, bot.version)
else:
self.safeBrowsingAPI = None
self.regex = re.compile(LinkChecker.regex_str, re.IGNORECASE)
self.run_later = run_later
self.cache = LinkCheckerCache() # cache[url] = True means url is safe, False means the link is bad
def highlight_id(date, highlight_id, highlight_title=None):
session = DBManager.create_session()
highlight = session.query(StreamChunkHighlight).filter_by(
id=highlight_id).first()
if highlight is None:
session.close()
return render_template('highlight_404.html'), 404
else:
stream_chunk = highlight.stream_chunk
stream = stream_chunk.stream
session.close()
return render_template('highlight.html',
highlight=highlight,
stream_chunk=stream_chunk,
stream=stream)
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 highlights():
session = DBManager.create_session()
dates_with_highlights = []
highlights = session.query(StreamChunkHighlight).order_by(StreamChunkHighlight.created_at.desc()).all()
for highlight in highlights:
dates_with_highlights.append(datetime.datetime(
year=highlight.created_at.year,
month=highlight.created_at.month,
day=highlight.created_at.day))
try:
return render_template('highlights.html',
highlights=highlights[:5],
dates_with_highlights=set(dates_with_highlights))
finally:
session.close()
def __init__(self, overrides={}):
UserDict.__init__(self)
self.db_session = DBManager.create_session()
self.default_settings = {
'broadcaster': 'test_broadcaster',
'ban_ascii': True,
'ban_msg_length': True,
'motd_interval_offline': 60,
'motd_interval_online': 5,
'max_msg_length': 350,
'lines_offline': True,
'parse_pyramids': False,
'check_links': True,
}
self.default_settings.update(overrides)
def __init__(self, overrides={}):
UserDict.__init__(self)
self.db_session = DBManager.create_session()
self.default_settings = {
'broadcaster': 'test_broadcaster',
'ban_ascii': True,
'ban_msg_length': True,
'motd_interval_offline': 60,
'motd_interval_online': 5,
'max_msg_length': 350,
'lines_offline': True,
'parse_pyramids': False,
'parse_emote_combo': False,
'check_links': True,
}
self.default_settings.update(overrides)
def __init__(self, overrides={}):
UserDict.__init__(self)
self.db_session = DBManager.create_session()
self.default_settings = {
"broadcaster": "test_broadcaster",
"ban_ascii": True,
"ban_msg_length": True,
"motd_interval_offline": 60,
"motd_interval_online": 5,
"max_msg_length": 350,
"lines_offline": True,
"parse_pyramids": False,
"parse_emote_combo": False,
"check_links": True,
}
self.default_settings.update(overrides)
def decorated_function(*args, **kwargs):
if 'user' not in session:
abort(403)
with DBManager.create_session_scope() as db_session:
user = db_session.query(User).filter_by(
username=session['user']['username']).one_or_none()
if user is None:
abort(403)
if user.level < level:
abort(403)
db_session.expunge(user)
kwargs['user'] = user
return f(*args, **kwargs)
def highlight_list_date(date):
# Make sure we were passed a valid date
try:
parsed_date = datetime.datetime.strptime(date, '%Y-%m-%d')
except ValueError:
# Invalid date
return redirect('/highlights/', 303)
session = DBManager.create_session()
highlights = session.query(StreamChunkHighlight).filter(cast(StreamChunkHighlight.created_at, Date) == parsed_date).order_by(StreamChunkHighlight.created_at.desc()).all()
try:
return render_template('highlights_date.html',
highlights=highlights,
date=parsed_date)
finally:
session.close()
def stats_duels():
session = DBManager.create_session()
data = {
'top_5_winners': session.query(UserDuelStats).order_by(UserDuelStats.duels_won.desc())[:5],
'top_5_points_won': session.query(UserDuelStats).order_by(UserDuelStats.profit.desc())[:5],
'top_5_points_lost': session.query(UserDuelStats).order_by(UserDuelStats.profit.asc())[:5],
'top_5_losers': session.query(UserDuelStats).order_by(UserDuelStats.duels_lost.desc())[:5],
'top_5_winrate': session.query(UserDuelStats).filter(UserDuelStats.duels_won >= 5).order_by(UserDuelStats.winrate.desc())[:5],
'bottom_5_winrate': session.query(UserDuelStats).filter(UserDuelStats.duels_won >= 5).order_by(UserDuelStats.winrate.asc())[:5],
}
try:
return render_template('stats_duels.html', **data)
finally:
session.close()
def pleblist_list():
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)
songs = session.query(PleblistSong).filter(
PleblistSong.stream_id == current_stream.id,
PleblistSong.date_played.is_(None)).all()
payload = {
'_total': len(songs),
'songs': [song.jsonify() for song in songs],
}
return jsonify(payload)
def go_offline(self):
with DBManager.create_session_scope(expire_on_commit=False) as db_session:
self.current_stream.ended = True
self.current_stream.stream_end = self.first_offline
self.current_stream_chunk.chunk_end = self.first_offline
db_session.add(self.current_stream)
db_session.add(self.current_stream_chunk)
db_session.commit()
db_session.expunge_all()
self.last_stream = self.current_stream
self.current_stream = None
self.current_stream_chunk = None
def __init__(self, bot, run_later):
self.db_session = DBManager.create_session()
self.blacklisted_links = []
self.whitelisted_links = []
if 'safebrowsingapi' in bot.config['main']:
self.safeBrowsingAPI = SafeBrowsingAPI(
bot.config['main']['safebrowsingapi'], bot.nickname,
bot.version)
else:
self.safeBrowsingAPI = None
self.regex = re.compile(LinkChecker.regex_str, re.IGNORECASE)
self.run_later = run_later
self.cache = LinkCheckerCache(
) # cache[url] = True means url is safe, False means the link is bad
def user_profile(username):
session = DBManager.create_session()
user = session.query(User).filter_by(username=username).one_or_none()
if user is None:
return render_template('no_user.html'), 404
rank = session.query(func.Count(User.id)).filter(User.points > user.points).one()
rank = rank[0] + 1
session.close()
user.rank = rank
if user:
return render_template('user.html',
user=user)
else:
return render_template('no_user.html'), 404
def user_profile(username):
session = DBManager.create_session()
user = session.query(User).filter_by(username=username).one_or_none()
if user is None:
return render_template('no_user.html'), 404
rank = session.query(func.Count(User.id)).filter(User.points > user.points).one()
rank = rank[0] + 1
user.rank = rank
user_duel_stats = session.query(UserDuelStats).filter_by(user_id=user.id).one_or_none()
try:
return render_template('user.html',
user=user,
user_duel_stats=user_duel_stats)
finally:
session.close()
