def create_song_request_queue(self, video_id, bot, source):
with DBManager.create_session_scope() as db_session:
song_info = SongRequestSongInfo._create_or_get(
db_session, video_id, self.youtube)
if not song_info:
log.error("There was an error!")
return False
if song_info.banned:
bot.whisper(source, "That song is banned! FeelsWeirdMan")
return False
skip_after = (self.settings["max_song_length"] if
song_info.duration > self.settings["max_song_length"]
else None)
songrequest_queue = SongrequestQueue._create(
db_session, video_id, skip_after, source.id)
db_session.commit()
m, s = divmod(int(songrequest_queue.playing_in(db_session)), 60)
m = int(m)
s = int(s)
playing_in = f"{m:02d}:{s:02d}"
if self.settings["send_message_in_chat"]:
bot.say(self.settings["message_in_chat"].format(
username=source.username_raw,
title=song_info.title,
current_pos=songrequest_queue.queue +
(1
if SongrequestQueue._get_current_song(db_session) else 0),
playing_in=playing_in,
))
self.bot.songrequest_manager._playlist()
return True
def inc_current_song(self):
while True:
if not self.enabled:
break
if self.current_song_id:
if not self.paused:
try:
with DBManager.create_session_scope() as db_session:
current_song = SongrequestQueue._from_id(
db_session, self.current_song_id)
next_song = SongrequestQueue._get_next_song(
db_session)
if not current_song or (
current_song.skip_after
and current_song.skip_after <
current_song.current_song_time + 10):
self.load_song()
else:
if (not current_song.requested_by
) and next_song and next_song.requested_by:
self.load_song()
current_song.current_song_time += 1
except Exception as e:
log.error(e)
elif self.module_opened:
self.load_song()
time.sleep(1)
def request_function(self, video_id, requested_by, queue=None):
if not self.module_state["enabled"]:
return False
with DBManager.create_session_scope() as db_session:
requested_by = User.find_by_user_input(db_session, requested_by)
if not requested_by:
return False
requested_by_id = requested_by.id
song_info = SongRequestSongInfo._create_or_get(
db_session, video_id, self.youtube)
if not song_info:
log.error("There was an error!")
return False
skip_after = (self.settings["max_song_length"] if
song_info.duration > self.settings["max_song_length"]
else None)
song = SongrequestQueue._create(db_session, video_id, skip_after,
requested_by_id)
if queue:
song._move_song(queue)
db_session.commit()
current_song = SongrequestQueue._from_id(db_session,
self.current_song_id)
if not current_song or not current_song.requested_by:
self.load_song()
return True
def _dump_state(self, db_session):
song = (SongrequestQueue._from_id(
db_session,
manager_ext.bot.songrequest_manager.current_song_id)
if manager_ext.bot.songrequest_manager.current_song_id
else None)
data = {
"volume":
manager_ext.bot.songrequest_manager.volume_val,
"current_song":
song.webjsonify() if song else {},
"module_state":
manager_ext.bot.songrequest_manager.module_state,
"playlist":
SongrequestQueue._get_playlist(db_session, limit=30),
"backup_playlist":
SongrequestQueue._get_backup_playlist(db_session,
limit=30),
"history_list":
SongrequestHistory._get_history(db_session, limit=30),
"banned_list":
SongRequestSongInfo._get_banned_list(db_session),
"favourite_list":
SongRequestSongInfo._get_favourite_list(db_session),
"current_timestamp":
str(utils.now().timestamp()),
}
payload = {"event": "initialize", "data": data}
self.sendMessage(json.dumps(payload).encode("utf8"), False)
def enable(self, bot):
if not self.bot:
return
import apiclient
from apiclient.discovery import build
def build_request(_, *args, **kwargs):
import httplib2
new_http = httplib2.Http()
return apiclient.http.HttpRequest(new_http, *args, **kwargs)
self.youtube = build("youtube",
"v3",
developerKey=self.settings["youtube_key"],
requestBuilder=build_request)
with DBManager.create_session_scope() as db_session:
SongrequestQueue._clear_backup_songs(db_session)
if self.settings["backup_playlist_id"] and self.settings[
"backup_playlist_id"] != "":
backup_songs = self.getBackUpListSongs()
random.shuffle(backup_songs)
SongrequestQueue._load_backup_songs(db_session, backup_songs,
self.youtube,
self.settings)
db_session.commit()
self.bot.songrequest_manager.enable(self.settings, self.youtube)
HandlerManager.add_handler(
"on_stream_stop",
self.bot.songrequest_manager.close_module_function)
def remove_function(self, database_id):
if not self.enabled:
return False
with DBManager.create_session_scope() as db_session:
song = SongrequestQueue._from_id(db_session, database_id)
song._remove(db_session)
db_session.commit()
SongrequestQueue._update_queue()
self._playlist()
return True
def requeue_function(self, database_id, requested_by):
if not self.enabled:
return False
with DBManager.create_session_scope() as db_session:
requested_by = User.find_by_user_input(db_session, requested_by)
if not requested_by:
return False
requested_by_id = requested_by.id
SongrequestHistory._from_id(db_session, database_id).requeue(
db_session, requested_by_id)
db_session.commit()
SongrequestQueue._update_queue()
self._playlist()
return True
def play_function(self, database_id, skipped_by):
if not self.enabled:
return False
with DBManager.create_session_scope() as db_session:
skipped_by = User.find_by_user_input(db_session, skipped_by)
if not skipped_by:
return
skipped_by_id = skipped_by.id
song = SongrequestQueue._from_id(db_session, database_id)
song._move_song(db_session, 1)
db_session.commit()
self.load_song(skipped_by_id)
SongrequestQueue._update_queue()
return True
def unban_function(self,
database_id=None,
hist_database_id=None,
songinfo_database_id=None):
if not self.module_state["enabled"]:
return False
if not songinfo_database_id and not database_id and not hist_database_id:
return False
with DBManager.create_session_scope() as db_session:
if database_id:
song = SongrequestQueue._from_id(db_session, int(database_id))
song_info = song.song_info
elif songinfo_database_id:
song_info = SongRequestSongInfo._get(db_session,
songinfo_database_id)
else:
song = SongrequestHistory._from_id(db_session,
int(hist_database_id))
song_info = song.song_info
if not song_info.banned:
return False
song_info.banned = False
db_session.merge(song_info)
db_session.commit()
self._playlist()
self._backup_playlist()
self._playlist_history()
self._favourite_list()
self._banned_list()
return True
def get_current_song(self, bot, source, message, **rest):
with DBManager.create_session_scope() as db_session:
current_song = SongrequestQueue._get_current_song(db_session)
if current_song:
m, s = divmod(current_song.playing_in(db_session), 60)
m = int(m)
s = int(s)
time_left = f"{m:02d}:{s:02d}"
if current_song.requested_by:
bot.say(
self.settings["message_in_chat_when_song_is_playing"].
format(
title=current_song.song_info.title,
requestor=current_song.requested_by.username_raw,
time_left=time_left,
))
return True
bot.say(self.settings["message_in_chat_when_song_is_playing"].
format(title=current_song.song_info.title,
requestor="Backup Playlist",
time_left=time_left))
return True
if self.settings["use_spotify"]:
is_playing, title, artistsArr = bot.spotify_api.state(
bot.spotify_token_manager)
if is_playing:
bot.say(self.settings[
"message_in_chat_when_song_is_playing_spotify"].format(
title=title,
artists=", ".join(
[str(artist) for artist in artistsArr])))
return True
bot.say(self.settings["message_in_chat_no_songs_playing"])
return True
def replay_function(self, requested_by):
if not self.enabled:
return False
with DBManager.create_session_scope() as db_session:
requested_by = User.find_by_user_input(db_session, requested_by)
if not requested_by:
return False
requested_by_id = requested_by.id
current_song = SongrequestQueue._from_id(db_session,
self.current_song_id)
self.request_function(current_song.video_id,
current_song.requested_by_id, 1)
db_session.commit()
self.load_song(requested_by_id)
SongrequestQueue._update_queue()
return True
def songrequest():
with DBManager.create_session_scope() as db_session:
playing_in = 0
track_number = 1
songs_queue = []
SongRequestQueueManager.force_reload()
queue_ids = SongRequestQueueManager.get_next_songs(50)
current_song = SongrequestQueue._get_current_song(db_session)
queue = ([current_song]
if current_song else []) + SongrequestQueue.sort(
queue_ids,
SongrequestQueue._from_list_id(db_session, queue_ids))
for song in queue:
if song.song_info is None:
continue
jsonify = song.webjsonify()
m, s = divmod(playing_in, 60)
m = int(m)
s = int(s)
jsonify["playing_in"] = (f"{m:02d}:{s:02d}"
if playing_in != 0 else
("Currently playing" if current_song
else "Song Request Closed"))
jsonify["track_number"] = track_number
playing_in += song.time_left
track_number += 1
songs_queue.append(jsonify)
history = (db_session.query(SongrequestHistory).filter(
SongrequestHistory.song_info.has(banned=False)).order_by(
SongrequestHistory.id.desc()).limit(50).all())
track_number = 1
songs_history = []
for song in history:
if song.song_info.banned:
continue
jsonify = song.webjsonify()
jsonify["track_number"] = track_number
track_number += 1
songs_history.append(jsonify)
return render_template("songrequest.html",
songs_queue=songs_queue,
songs_history=songs_history,
live=StreamManager.online)
def move_function(self, database_id, to_id):
if not self.module_state["enabled"]:
return False
with DBManager.create_session_scope() as db_session:
song = SongrequestQueue._from_id(db_session, database_id)
song._move_song(to_id)
db_session.commit()
self._playlist()
return True
def seek_function(self, _time):
if not self.enabled:
return False
if self.current_song_id:
with DBManager.create_session_scope() as db_session:
current_song = SongrequestQueue._from_id(
db_session, self.current_song_id)
current_song.current_song_time = _time
self._seek(_time)
return True
return False
def _dump_state(self, db_session):
current_song = SongrequestQueue._from_id(
db_session,
manager_ext.bot.songrequest_manager.current_song_id)
data = {
"event": "initialize",
"data": {
"currentSong":
current_song.webjsonify() if current_song else None,
"playlist":
SongrequestQueue._get_playlist(db_session, 15),
"history":
SongrequestHistory._get_history(db_session, 15),
"paused":
manager_ext.bot.songrequest_manager.paused,
"open":
manager_ext.bot.songrequest_manager.module_opened,
"volume":
manager_ext.bot.songrequest_manager.volume_val(),
},
}
payload = json.dumps(data).encode("utf8")
self.sendMessage(payload, False)
def ban_function(self, database_id=None, hist_database_id=None):
if not self.module_state["enabled"] or (not database_id
and not hist_database_id):
return False
with DBManager.create_session_scope() as db_session:
if database_id:
song = SongrequestQueue._from_id(db_session, int(database_id))
else:
song = SongrequestHistory._from_id(db_session,
int(hist_database_id))
if song.song_info.banned:
return False
song.song_info.banned = True
db_session.merge(song.song_info)
SongrequestQueue._pruge_videos(db_session, song.video_id)
db_session.commit()
self._playlist()
self._backup_playlist()
self._playlist_history()
self._favourite_list()
self._banned_list()
return True
def requeue_function(self, database_id, requested_by):
if not self.module_state["enabled"]:
return False
with DBManager.create_session_scope() as db_session:
requested_by = User.find_by_user_input(db_session, requested_by)
if not requested_by:
return False
requested_by_id = requested_by.id
SongrequestHistory._from_id(db_session, database_id).requeue(
db_session, requested_by_id)
db_session.commit()
current_song = SongrequestQueue._from_id(db_session,
self.current_song_id)
if not current_song or not current_song.requested_by:
self.load_song()
self._playlist()
return True
def pause_function(self):
if not self.module_state["enabled"] or not self.current_song_id:
return False
if not self.module_state["paused"]:
self.module_state["paused"] = True
self._module_state()
self._pause()
self.remove_schedule()
with DBManager.create_session_scope() as db_session:
song = SongrequestQueue._from_id(db_session,
self.current_song_id)
song.played_for = (utils.now() -
song.date_resumed).total_seconds()
song.date_resumed = None
return True
return False
def seek_function(self, _time):
if not self.module_state["enabled"]:
return False
if self.current_song_id:
with DBManager.create_session_scope() as db_session:
current_song = SongrequestQueue._from_id(
db_session, self.current_song_id)
current_song.played_for += _time - current_song.current_song_time
db_session.merge(current_song)
db_session.commit()
self.remove_schedule()
self.schedule_job_id = random.randint(1, 100000)
self.current_song_schedule = ScheduleManager.execute_delayed(
current_song.time_left + 10,
self.load_song_schedule,
args=[self.schedule_job_id])
self._seek(_time, current_song.webjsonify())
return True
return False
def resume_function(self):
if not self.module_state["enabled"] or not self.current_song_id:
return False
if self.module_state["paused"]:
self.module_state["paused"] = False
self._module_state()
self._resume()
with DBManager.create_session_scope() as db_session:
song = SongrequestQueue._from_id(db_session,
self.current_song_id)
song.date_resumed = utils.now()
self.schedule_job_id = random.randint(1, 100000)
self.current_song_schedule = ScheduleManager.execute_delayed(
song.time_left + 10,
self.load_song_schedule,
args=[self.schedule_job_id])
return True
return False
def get_next_song(self, bot, source, message, **rest):
with DBManager.create_session_scope() as db_session:
next_song = SongrequestQueue._get_next_song(db_session)
if next_song:
m, s = divmod(next_song.playing_in(db_session), 60)
m = int(m)
s = int(s)
playing_in = f"{m:02d}:{s:02d}"
if next_song.requestor:
bot.say(
self.settings["message_in_chat_when_next_song"].format(
title=next_song.song_info.title,
requestor=next_song.requestor.username_raw,
playing_in=playing_in,
))
return True
bot.say(self.settings["message_in_chat_when_next_song"].format(
title=next_song.song_info.title,
requestor="Backup Playlist",
playing_in=playing_in))
return True
bot.say(self.settings["message_in_chat_when_next_song_none"])
return True
def load_song(self, skipped_by_id=None):
if not self.module_state["enabled"]:
return False
if self.current_song_id:
with DBManager.create_session_scope() as db_session:
current_song = SongrequestQueue._from_id(
db_session, self.current_song_id)
if current_song:
if current_song.current_song_time > 5:
self.previous_queue = 0
histroy = current_song._to_histroy(
db_session, skipped_by_id)
if not histroy:
log.info(
"History not added because stream is offline!")
else:
current_song._remove(db_session)
self._stop_video()
self._hide()
db_session.commit()
self._playlist_history()
self.current_song_id = None
self.schedule_job_id = None
self.module_state["paused"] = False
self._module_state()
self.remove_schedule()
if not self.module_state["requests_open"]:
if self.previously_playing_spotify:
self.bot.spotify_api.play(self.bot.spotify_token_manager)
log.info("Resumed Spotify")
self.previously_playing_spotify = False
return False
with DBManager.create_session_scope() as db_session:
current_song = SongrequestQueue._get_current_song(db_session)
if not current_song:
current_song = SongrequestQueue._pop_next_song(db_session)
if current_song:
SongRequestQueueManager.update_song_playing_id(current_song.id)
current_song.played_for = 0
current_song.date_resumed = utils.now()
self.current_song_id = current_song.id
self._volume()
self._play(current_song.video_id, current_song.webjsonify())
self.schedule_job_id = random.randint(1, 100000)
self.current_song_schedule = ScheduleManager.execute_delayed(
current_song.time_left + 10,
self.load_song_schedule,
args=[self.schedule_job_id])
if self.settings["use_spotify"]:
is_playing, song_name, artistsArr = self.bot.spotify_api.state(
self.bot.spotify_token_manager)
if is_playing:
self.bot.spotify_api.pause(
self.bot.spotify_token_manager)
self.previously_playing_spotify = True
if not current_song.requested_by_id:
SongrequestQueue._create(db_session,
current_song.video_id,
current_song.skip_after,
None,
backup=True)
db_session.commit()
if current_song.requested_by_id:
self._playlist()
else:
self._backup_playlist()
return True
if not current_song:
SongRequestQueueManager.update_song_playing_id("")
if self.settings["use_spotify"]:
if self.previously_playing_spotify:
self.bot.spotify_api.play(self.bot.spotify_token_manager)
log.info("Resumed Spotify")
self.previously_playing_spotify = False
if self.is_video_showing:
self._hide()
return False
def load_song(self, skipped_by_id=None):
if not self.enabled:
return False
if self.current_song_id:
with DBManager.create_session_scope() as db_session:
current_song = SongrequestQueue._from_id(
db_session, self.current_song_id)
if current_song:
if current_song.current_song_time > 5:
self.previous_queue = 0
histroy = current_song._to_histroy(
db_session, skipped_by_id)
if not histroy:
log.info(
"History not added because stream is offline!")
else:
current_song._remove(db_session)
self._stop_video()
self._hide()
db_session.commit()
self._playlist_history()
SongrequestQueue._update_queue()
self.current_song_id = None
if not self.module_opened:
return False
with DBManager.create_session_scope() as db_session:
current_song = SongrequestQueue._get_current_song(db_session)
if not current_song:
current_song = SongrequestQueue._get_next_song(db_session)
if current_song:
current_song.playing = True
current_song.queue = 0
current_song.current_song_time = 0
self.current_song_id = current_song.id
song_info = current_song.song_info
self._play(
current_song.video_id,
song_info.title,
current_song.requested_by.username_raw
if current_song.requested_by else "Backup list",
)
if self.settings["use_spotify"]:
is_playing, song_name, artistsArr = self.bot.spotify_api.state(
self.bot.spotify_token_manager)
if is_playing:
self.bot.spotify_api.pause(
self.bot.spotify_token_manager)
self.previously_playing_spotify = True
if not current_song.requested_by_id:
SongrequestQueue._create(
db_session,
current_song.video_id,
current_song.skip_after,
None,
SongrequestQueue._get_next_queue(db_session),
)
db_session.commit()
self._playlist()
SongrequestQueue._update_queue()
return True
if self.settings["use_spotify"]:
if self.previously_playing_spotify:
self.bot.spotify_api.play(self.bot.spotify_token_manager)
self.previously_playing_spotify = False
if self.isVideoShowing:
self._hide()
return False
def _backup_playlist(self):
with DBManager.create_session_scope() as db_session:
playlist = SongrequestQueue._get_backup_playlist(db_session, 30)
self.bot.songrequest_websocket_manager.emit(
"backup_playlist", {"backup_playlist": playlist})
