Пример #1
0
    def post(self, party_id):
        # Export the specified party to Spotify. If the export_playlist field
        # from the database is populated and still exists in Spotify, just
        # update this playlist. Otherwise, create a new playlist.
        client = recreate_client_from_session()
        user_id = get_user_id()
        if not user_id or not client:
            abort(403, "User is not logged in to Spotify.")

        if database.check_party_exists(party_id):
            if database.is_user_party_host(user_id, party_id):
                # Okay, we're authenticated and everything exists.
                # Retrieve party details from database.
                details = database.get_party(party_id)
                if not details:
                    return {
                        "message":
                        "Unable to get information about the party from database!",
                        "success": False
                    }

                prev_playlist = database.get_party_exported_playlist(party_id)
                if prev_playlist and prev_playlist != "none":
                    old_playlist_id = prev_playlist.split(":")[4]
                    result = client.api.me_unfollow_playlist(
                        user_id, old_playlist_id)

                # Create a new playlist using name and description from database.
                playlist = client.api.user_playlist_create(
                    user_id,
                    details["meta"]["party_name"],
                    description=details["meta"]["party_description"])
                playlist_id = playlist["id"]
                database.update_party_exported_playlist(
                    party_id,
                    "spotify:user:{}:playlist:{}".format(user_id, playlist_id))

                # Sort and reorder song_uris by song_votes, descending.
                song_votes = [song["votes"] for song in details["songs"]]
                song_uris = [
                    "spotify:track:{}".format(song["song_id"])
                    for song in details["songs"]
                ]
                sorted_idx = sorted(range(len(song_votes)),
                                    key=lambda k: song_votes[k],
                                    reverse=True)
                sorted_uris = [song_uris[i] for i in sorted_idx]
                # Add songs from database to the new playlist.
                client.api.user_playlist_tracks_add(user_id, playlist_id,
                                                    sorted_uris)

                return {
                    "message": "Successfully exported party to Spotify.",
                    "success": True
                }
            else:
                abort(403, "User is not party host.")
        else:
            abort(404, "Party does not exist.")
Пример #2
0
def jukebox_create_party():
    user_id = get_user_id()
    # We are *creating* a new party.
    if user_id:
        return render_template("jukebox_create_party.html",
                               context=get_jinja_context())
    else:
        # We don't have a valid token stored. User is not authorized.
        # Redirect to Spotify for authorization.
        return redirect(url_for("welcome"))
Пример #3
0
def jukebox_user_account():
    # We are displaying the user's account details.
    user_id = get_user_id()
    if user_id:
        additional_context = {
            "user_parties": database.get_user_parties(user_id)
        }
        return render_template("jukebox_user_account.html",
                               context=get_jinja_context(additional_context))
    else:
        return redirect("welcome")
Пример #4
0
 def delete(self, party_id):
     """Delete a party and remove it from the database. This action requires
     that the logged in user is also the party host.
     """
     client = recreate_client_from_session()
     user_id = get_user_id()
     if client and user_id:
         if database.is_user_party_host(user_id, party_id):
             database.delete_party(party_id)
             return {
                 "message":
                 "Successfully deleted party {}.".format(party_id),
                 "success": True
             }
         else:
             abort(403, "User is not the party host.")
     else:
         abort(403, "User is not logged in to Spotify.")
Пример #5
0
 def post(self):
     user_id = get_user_id()
     party_details = request.get_json()
     if user_id:
         msg = ""
         party_id = party_details["party_id"]
         if "name" in party_details:
             new_name = party_details["name"]
             database.update_party_name(party_id, new_name)
             msg += "Updated party name to '{}'. ".format(new_name)
         if "description" in party_details:
             new_description = party_details["description"]
             database.update_party_description(party_id, new_description)
             msg += "Updated party description to '{}'. ".format(
                 new_description)
         if "name" not in party_details and "description" not in party_details:
             abort(400, "Bad data payload.")
         return {"message": msg, "success": True}
     else:
         abort(403, "User has not logged in to Spotify.")
Пример #6
0
    def post(self):
        """ Create a new party. User must be authenticated and have a stored session. """
        client = recreate_client_from_session()
        user_id = get_user_id()
        party_details = request.get_json()
        if client and user_id:
            # Create the playlist.
            party_name = party_details["name"]
            party_description = party_details["description"]
            party_starter_playlist = party_details["playlist"]

            ## Get the tracklist in URIs for the submitted starter playlist.
            # First, get the URI and parse out the playlist ID. The ID is the
            # last bit after ``playlist:``:
            #
            #       spotify:user:spotify:playlist:37i9dQZF1DX4JAvHpjipBk
            #                    ^ user_id        ^ playlist ID
            if party_starter_playlist:
                starter_playlist_user_id = party_starter_playlist.split(":")[2]
                starter_playlist_id = party_starter_playlist.split(":")[4]

                # Now, retrieve the playlist's tracks from Spotify's API.
                received_data = client.api.user_playlist_tracks(
                    starter_playlist_user_id, starter_playlist_id)
                tracks = [item["track"] for item in received_data["items"]]
            else:
                tracks = []

            # Add the party and itself details into the database.
            party_id = generate_party_id()
            database.create_party(user_id, party_id, party_name,
                                  party_description, party_starter_playlist,
                                  tracks)

            return {
                "party_id": party_id,
                "message":
                "Created new party: {}".format(party_details["name"])
            }
        else:
            abort(403, "User has not logged in to Spotify.")
Пример #7
0
def jukebox_view_party(party_id):
    user_id = get_user_id()  # get user_id from session, if exists
    if party_id and database.check_party_exists(party_id):
        # We are *viewing* an existing party. Check if the current user is
        # logged in, and if so, if they are the party host.
        party_details = database.get_party(party_id)
        highlight = request.args.get("highlight")
        additional_context = {
            "party_id": party_id,
            "party_name": party_details["meta"]["party_name"],
            "party_description": party_details["meta"]["party_description"],
            "tracks": party_details["songs"],
            "is_user": user_id is not None,
            "is_party_host": database.is_user_party_host(user_id, party_id),
            "highlight": highlight
        }
        return render_template("jukebox_view_party.html",
                               context=get_jinja_context(additional_context))
    else:
        return render_template("jukebox_party_does_not_exist.html",
                               context=get_jinja_context())
Пример #8
0
 def post(self, party_id, song_uri):
     client = recreate_client_from_session()
     user_id = get_user_id()
     if user_id:
         try:
             song_id = song_uri.split(":")[2]
         except:
             abort(400, "Invalid song URI.")
         track = client.api.track(song_id)
         if database.add_song_to_party(party_id, song_id, track):
             return {
                 "message":
                 "Added song {} to party {}.".format(song_id, party_id),
                 "success":
                 True
             }
         else:
             return {
                 "message": "Specified party does not exist.",
                 "success": False
             }
     else:
         abort(403, "User has not logged in to Spotify.")
Пример #9
0
def welcome():
    user_id = get_user_id()
    if user_id:
        return redirect(url_for("jukebox_user_account"))
    else:
        return render_template("welcome.html", context=get_jinja_context())