Beispiel #1
0
 def __init__(self, title='unknown', songs=[], artist=None):
     Playlist.__init__(self, songs, 0)
     self.title = title
     self.artist = artist
     self.artwork = None
     self.placeholder = None
     self.item = None
Beispiel #2
0
    def create_playlist(self, name, description, add_random_torrents=False):
        playlist = Playlist(len(self.playlists) + 1, name, description)

        if add_random_torrents:
            picked_torrents = sample(self.torrents, randint(0, min(20, len(self.torrents))))
            for torrent in picked_torrents:
                playlist.add_torrent(torrent)

        self.playlists.add(playlist)
Beispiel #3
0
 async def save(self, ctx: commands.Context, *, title: str = None):
     """Sauvegarde une playliste."""
     if not title:
         raise Exception("Vous devez préciser un nom pour votre playliste.")
     playlist_id = title
     music = self.bot.get_cog("Music")
     Playlist.create(ctx, self.playlists[playlist_id], title, music)
     self.user_playlists[ctx.author.id] = playlist_id
     msg = "La playliste a été sauvegardée."
     return await ctx.send(msg)
Beispiel #4
0
def create_playlist():
    backup_playlist_arg = request.args.get('backup_id')

    playlist_query = Playlist.objects(backup_playlist=backup_playlist_arg).first()
    if playlist_query:
        result = str(playlist_query.playlist_hash)
    else:
        playlist = Playlist(backup_playlist=backup_playlist_arg).save()
        playlist_query = Playlist.objects(backup_playlist=backup_playlist_arg).first()
    result = playlist_query.playlist_hash

    return jsonify(result=result)
Beispiel #5
0
def get_playlist():
    playlist_arg = request.args.get('playlist_hash')
    playlist = Playlist.objects(playlist_hash=playlist_arg).first()

    if playlist.currently_playing:        
        currently_playing = dict(
            adder=playlist.currently_playing['adder'],
            artist=playlist.currently_playing['artist'],
            album=playlist.currently_playing['album'],
            track=playlist.currently_playing['track'],
            added=playlist.currently_playing['added'],
            vote_rating=playlist.currently_playing['vote_rating'],
            voters=playlist.currently_playing['voters'],
            uri=playlist.currently_playing['uri'])
    else:
        currently_playing = dict(
            adder=None,
            artist=None,
            album=None,
            track=None,
            added=None,
            vote_rating=None,
            voters=None,
            uri=None)

    result = dict(
        playlist=str(playlist.id),
        updated=playlist.updated.strftime('%Y-%M-%d %H:%M:%S'),
        currently_playing=currently_playing,
        tracks=playlist.tracks)

    return jsonify(result=result)
Beispiel #6
0
def callback():
    # Auth Step 4: Requests refresh and access tokens
    auth_token = request.args['code']
    code_payload = {
        "grant_type": "authorization_code",
        "code": str(auth_token),
        "redirect_uri": REDIRECT_URI,
        'client_id': CLIENT_ID,
        'client_secret': CLIENT_SECRET,
    }
    post_request = requests.post(SPOTIFY_TOKEN_URL, data=code_payload)

    # Auth Step 5: Tokens are Returned to Application
    response_data = json.loads(post_request.text)
    access_token = response_data["access_token"]
    refresh_token = response_data["refresh_token"]
    token_type = response_data["token_type"]
    expires_in = response_data["expires_in"]

    # Auth Step 6: Use the access token to access Spotify API
    authorization_header = {"Authorization": "Bearer {}".format(access_token)}

    # Get profile data
    user_profile_api_endpoint = "{}/me".format(SPOTIFY_API_URL)
    profile_response = requests.get(user_profile_api_endpoint,
                                    headers=authorization_header)
    profile_data = json.loads(profile_response.text)
    user = User(spotify_id=profile_data['id'],
                name=profile_data['display_name'],
                jwt=access_token)
    user_check = User.query.filter_by(spotify_id=profile_data['id']).first()

    # Updates DB
    if not user_check:
        user.save()
    else:
        user_check.name = user.name
        user_check.spotify_id = user.spotify_id
        user_check.jwt = user.jwt
        user_check.save()
        user = user_check

    login_user(user)

    # Get user playlist data
    playlist_api_endpoint = "{}/playlists".format(profile_data["href"])
    playlists_response = requests.get(playlist_api_endpoint,
                                      headers=authorization_header)
    playlist_data = json.loads(playlists_response.text)

    playlists = []
    for item in playlist_data["items"]:
        playlists.append(
            Playlist(spotify_id=item['id'],
                     name=item['name'],
                     image=item['images'][0]['url']).to_json())

    session['playlists'] = playlists
    return redirect(url_for('web.like'))
Beispiel #7
0
def next_track():
    playlist_arg = request.args.get('playlist_hash')

    playlist = Playlist.objects(playlist_hash=playlist_arg).first()
    next_track = playlist.get_next_track()
    result = dict(track=next_track['track'], artist=next_track['artist'], album=next_track['album'], uri=next_track['uri'])
    playlist.update_que()
    return jsonify(result=result)
Beispiel #8
0
 def get_playlist(self, ctx: commands.Context, title: str = None):
     """Return a playlist with an id."""
     if not ctx.author.id in self.user_playlists:
         raise Exception(
             "Utilisez 'playlist select [title]' pour sélectionner une playliste."
         )
     playlist_id = self.user_playlists[ctx.author.id]
     if not playlist_id in self.playlists:
         raise Exception(f"La playliste d'id {playlist_id} n'existe pas.")
     return Playlist(self.playlists[playlist_id])
def select(id):
    playlist = None
    sql = "SELECT * FROM playlists WHERE id = %s"
    values = [id]
    result = run_sql(sql, values)[0]

    if result is not None:
        league_type = league_type_repo.select(result['league_type_id'])
        playlist = Playlist(league_type, result['round_no'])
    return playlist
Beispiel #10
0
def add_vote():
    playlist_arg = request.args.get('playlist_hash')
    uri_arg = request.args.get('uri')
    facebook_id_arg = request.args.get('facebook_id')
    vote_arg = request.args.get('vote')

    playlist = Playlist.objects(playlist_hash=playlist_arg).first()
    playlist.vote(uri_arg, facebook_id_arg, vote_arg)
    playlist.update_que()
    return jsonify(result='Voted on track.')
def select_all():
    playlists = []

    sql = "SELECT * FROM playlists"
    results = run_sql(sql)

    for result in results:
        league_type = league_type_repo.select(result['league_type_id'])
        playlist = Playlist(league_type, result['round_no'])
        playlists.append(playlist)
    return playlists
Beispiel #12
0
def url_add_track():
    playlist_arg = request.args.get('playlist_hash')
    facebook_id_arg = request.args.get('facebook_id')
    track_arg = request.args.get('track')
    artist_arg = request.args.get('artist')
    album_arg = request.args.get('album')
    uri_arg = request.args.get('uri')

    print 'track_arg', track_arg

    playlist = Playlist.objects(playlist_hash=playlist_arg).first()
    playlist.add_track(facebook_id_arg, track_arg, artist_arg, album_arg, uri_arg)
    playlist.update_que()
    return jsonify(result='Added track.')
Beispiel #13
0
 def set_playlist(self, name, description, assets):
     self.kv.set_playlist(name, Playlist(name, description, assets))
Beispiel #14
0
 def get_playlist_from_id(self, playlist_id: str):
     """Return a playlist given its id."""
     if playlist_id in self.playlists:
         return Playlist(self.playlists[playlist_id])
     else:
         raise Exception(f"La playliste d'id {playlist_id} n'existe pas.")
Beispiel #15
0
def check_update():
    playlist_arg = request.args.get('playlist_hash')

    playlist = Playlist.objects(playlist_hash=playlist_arg).first()
    result = playlist.updated.strftime('%Y-%M-%d %H:%M:%S')
    return jsonify(result=result)