Struct SpapiConfig

pub struct SpapiConfig {
    pub client_id: String,
    pub client_secret: String,
    pub refresh_token: String,
    pub marketplace_id: String,
    pub region: String,
    pub sandbox: bool,
    pub user_agent: Option<String>,
    pub timeout_sec: Option<u64>,
}

Fields

client_id: String

client_secret: String

refresh_token: String

marketplace_id: String

region: String

sandbox: bool

user_agent: Option<String>

timeout_sec: Option<u64>

Implementations

impl SpapiConfig

pub fn from_env() -> Result<Self>

Examples found in repository

examples/sellers_v1.rs (line 6)

async fn main() -> Result<()> {
    let config = SpapiConfig::from_env()?;
    let client = SpapiClient::new(config.clone())?;

    let marketplace = client.get_marketplace_participations().await?;
    println!("Marketplace: {:#?}", marketplace);
    println!("{}", marketplace.payload.ok()?[0].marketplace.name);

    Ok(())
}

examples/fba_inventory_v1.rs (line 49)

async fn main() -> Result<()> {
    let client = SpapiClient::new(SpapiConfig::from_env()?)?;

    let inventory_summaries = get_inventory_summaries_all(&client, Some(false)).await?;
    log::info!("Fetched {} inventory summaries", inventory_summaries.len());
    for summary in inventory_summaries {
        log::info!("Inventory Summary: {:?}", summary);
    }

    Ok(())
}

examples/pricing_v0.rs (line 6)

async fn main() -> Result<()> {
    let client = SpapiClient::new(SpapiConfig::from_env()?)?;

    // let res = client
    //     .get_item_offers(client.get_marketplace_id(), "B0DGJC52FP", "New", None)
    //     .await?;
    // println!("Item offers: {:?}", res);

    let res = client
        .get_item_offers_batch_by_asins(vec!["B0DGJC52FP", "B0BN72FYFG"])
        .await?;
    println!("Batch item offers: {:?}", res);

    // let res = client
    //     .get_listing_offers_batch_by_skus(vec!["YOU_SKU1", "YOU_SKU2"])
    //     .await?;
    // println!("Batch listing offers: {:?}", res);
    

    Ok(())
}

examples/sellers_v1_use_raw_api.rs (line 7)

async fn main() -> Result<()> {
    let spapi_config = SpapiConfig::from_env()?;
    let spapi_client = SpapiClient::new(spapi_config.clone())?;
    {
        // Internally refresh the access token and create a configuration
        // Configuration must be created for each API call
        let configuration = spapi_client.create_configuration().await?;

        // Wait for rate limit before making the API call
        // When _guard is dropped, the rate limiter will mark the api call as having received a response
        let _guard = spapi_client
            .limiter()
            .wait("get_marketplace_participations", 0.016, 15)
            .await?;

        // Call the API to get marketplace participations
        let res = get_marketplace_participations(&configuration).await?;
        
        println!("Marketplace Participations: {:#?}", res);
    }
    Ok(())
}

examples/product_fees_v0.rs (line 6)

async fn main() -> Result<()> {
    let client = SpapiClient::new(SpapiConfig::from_env()?)?;

    // let fee = client.get_fee_for_asin("B0DGJC52FP", 999.0, true).await?;
    // println!("Fee for ASIN B0DGJC52FP: ${:.2}", fee);

    let current_local_time = chrono::Local::now();
    println!("Current local time: {}", current_local_time);
    {
        let fees = client
            .get_fees_for_asins(vec![("B0DGJC52FP".to_string(), 999.0)], true)
            .await?;
        println!("Fees for ASINs: {:?}", fees);
    }
    let current_local_time = chrono::Local::now();
    println!("Current local time: {}", current_local_time);
    {
        let fees = client
            .get_fees_for_asins(vec![("B0DGJC52FP".to_string(), 999.0)], true)
            .await?;
        println!("Fees for ASINs: {:?}", fees);
    }
    let current_local_time = chrono::Local::now();
    println!("Current local time: {}", current_local_time);
    {
        let fees = client
            .get_fees_for_asins(vec![("B0DGJC52FP".to_string(), 999.0)], true)
            .await?;
        println!("Fees for ASINs: {:?}", fees);
    }
    let current_local_time = chrono::Local::now();
    println!("Current local time: {}", current_local_time);

    Ok(())
}

examples/reports.rs (line 182)

async fn main() -> Result<()> {
    env_logger::init();

    let spapi_config = SpapiConfig::from_env()?;
    let client = SpapiClient::new(spapi_config.clone())?;
    let marketplace_ids = vec!["ATVPDKIKX0DER".to_string()]; // Amazon US Marketplace ID

    // create report specification
    let report_type = "GET_RESTOCK_INVENTORY_RECOMMENDATIONS_REPORT";
    let report_content = client
        .fetch_report(
            report_type,
            marketplace_ids.clone(),
            None,
            Some(|attempt, status| {
                println!("Attempt get report {}: {:?}", attempt, status);
            }),
        )
        .await?;

    // save report content to a file
    let report_file_path = "/tmp/restock_inventory_report.txt";
    std::fs::write(report_file_path, &report_content)
        .expect("Unable to write report content to file");

    // // load report content from the file
    // let report_file_path = "/tmp/restock_inventory_report.txt";
    // let report_content =
    //     std::fs::read_to_string(report_file_path).expect("Unable to read report content from file");

    let restocks = parse_restock_report(&report_content);

    println!("Restock inventory report generated successfully.");
    println!("{:#?}", restocks);

    Ok(())
}

Additional examples can be found in:

• examples/update_price.rs

Trait Implementations

impl Clone for SpapiConfig

fn clone(&self) -> SpapiConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SpapiConfig

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SpapiConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for SpapiConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.