Struct Album 

pub struct Album<'a> { /* private fields */ }

Represents album-related operations in the Last.fm API.

Implementations

impl<'a> Album<'a>

pub fn get_tags(&mut self) -> AlbumGetTags<'_>

Creates a request to get tags for the album.

Examples found in repository

examples/album_get_tags.rs (line 18)

async fn main() -> Result<(), Box<dyn Error>> {
    dotenv().ok();
    let api_key = std::env::var("API_KEY").expect("API_KEY env variable is required");
    let api_secret = std::env::var("API_SECRET").expect("API_SECRET env variable is required");

    let lastfm = Lastfm::builder()
        .api_key(api_key)
        .api_secret(api_secret)
        .build()?;

    let response = lastfm
        .album()
        .get_tags()
        .artist("Billie Eilish")
        .album("HIT ME HARD AND SOFT")
        .user("uppercase_")
        .autocorrect(true)
        .send()
        .await?;

    match response {
        APIResponse::Success(value) => {
            println!("{}", serde_json::json!(value));
        }
        APIResponse::Error(err) => {
            println!("Error: {} - {}", err.error, err.message);
        }
    }

    Ok(())
}

pub fn add_tags(&mut self) -> AlbumAddTagsRequest<'_>

Creates a request to add tags to the album.

Examples found in repository

examples/album_add_tags.rs (line 23)

async fn main() -> Result<(), Box<dyn Error>> {
    dotenv().ok();
    let api_key = std::env::var("API_KEY").expect("API_KEY env variable is required");
    let api_secret = std::env::var("API_SECRET").expect("API_SECRET env variable is required");
    let sk = std::env::var("SK").expect("SK env variable is required");

    let lastfm = Lastfm::builder()
        .api_key(api_key)
        .api_secret(api_secret)
        .session_key(sk)
        .build()?;

    lastfm.auth();
    // lastfm.set_sk(sk);

    let response = lastfm
        .album()
        .add_tags()
        .artist("Billie Eilish")
        .album("HIT ME HARD AND SOFT")
        .tags("aoty")
        .send()
        .await?;

    match response {
        APIResponse::Success(value) => {
            println!("{}", value);
        }
        APIResponse::Error(err) => {
            println!("Error: {} - {}", err.error, err.message);
        }
    }

    Ok(())
}

pub fn get_info(&mut self) -> AlbumGetInfo<'_>

Examples found in repository

examples/album_get_info.rs (line 18)

async fn main() -> Result<(), Box<dyn Error>> {
    dotenv().ok();
    let api_key = std::env::var("API_KEY").expect("API_KEY env variable is required");
    let api_secret = std::env::var("API_SECRET").expect("API_SECRET env variable is required");

    let lastfm = Lastfm::builder()
        .api_key(api_key)
        .api_secret(api_secret)
        .build()?;

    let response = lastfm
        .album()
        .get_info()
        .artist("Billie Eilish")
        .album("HIT ME HARD AND SOFT")
        .username("uppercase_")
        .autocorrect(true)
        .send()
        .await?;

    match response {
        APIResponse::Success(value) => {
            println!("{:?}", value.album);
        }
        APIResponse::Error(err) => {
            println!("Error: {} - {}", err.error, err.message);
        }
    }

    Ok(())
}

pub fn get_top_tags(&mut self) -> AlbumGetTopTags<'_>

Examples found in repository

examples/album_get_top_tags.rs (line 18)

async fn main() -> Result<(), Box<dyn Error>> {
    dotenv().ok();
    let api_key = std::env::var("API_KEY").expect("API_KEY env variable is required");
    let api_secret = std::env::var("API_SECRET").expect("API_SECRET env variable is required");

    let lastfm = Lastfm::builder()
        .api_key(api_key)
        .api_secret(api_secret)
        .build()?;

    let response = lastfm
        .album()
        .get_top_tags()
        .artist("Billie Eilish")
        .album("HIT ME HARD AND SOFT")
        .autocorrect(true)
        .send()
        .await?;

    match response {
        APIResponse::Success(value) => {
            println!("{:?}", value);
        }
        APIResponse::Error(err) => {
            println!("Error: {} - {}", err.error, err.message);
        }
    }

    Ok(())
}

pub fn remove_tag(&mut self) -> AlbumRemoveTag<'_>

Examples found in repository

examples/album_remove_tags.rs (line 23)

async fn main() -> Result<(), Box<dyn Error>> {
    dotenv().ok();
    let api_key = std::env::var("API_KEY").expect("API_KEY env variable is required");
    let api_secret = std::env::var("API_SECRET").expect("API_SECRET env variable is required");
    let sk = std::env::var("SK").expect("SK env variable is required");

    let lastfm = Lastfm::builder()
        .api_key(api_key)
        .api_secret(api_secret)
        .session_key(sk)
        .build()?;

    let _sk = lastfm.auth();
    // lastfm.set_sk(sk);

    let response = lastfm
        .album()
        .remove_tag()
        .artist("Billie Eilish")
        .album("HIT ME HARD AND SOFT")
        .tag("aoty")
        .send()
        .await?;

    match response {
        APIResponse::Success(value) => {
            println!("{}", value);
        }
        APIResponse::Error(err) => {
            println!("Error: {} - {}", err.error, err.message);
        }
    }

    Ok(())
}

pub fn search(&mut self) -> AlbumSearch<'_>

Examples found in repository

examples/album_search.rs (line 18)

async fn main() -> Result<(), Box<dyn Error>> {
    dotenv().ok();
    let api_key = std::env::var("API_KEY").expect("API_KEY env variable is required");
    let api_secret = std::env::var("API_SECRET").expect("API_SECRET env variable is required");

    let lastfm = Lastfm::builder()
        .api_key(api_key)
        .api_secret(api_secret)
        .build()?;

    let response = lastfm
        .album()
        .search()
        .album("HIT ME HARD AND SOFT")
        .limit(30)
        .page(1)
        .send()
        .await?;

    match response {
        APIResponse::Success(value) => {
            println!("{}", value);
        }
        APIResponse::Error(err) => {
            println!("Error: {} - {}", err.error, err.message);
        }
    }

    Ok(())
}

Trait Implementations

impl<'a> Debug for Album<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.