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})