Beispiel #1
0
 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
Beispiel #2
0
 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
Beispiel #3
0
    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)
Beispiel #4
0
    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
Beispiel #5
0
    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