Struct Config

pub struct Config {
    pub woo: Woo,
}

Configuration struct for storing Woo parameters

Fields

woo: Woo

The Woo struct containing ck, cs, and host strings

Implementations

impl Config

pub fn new<T: ToString>(file_name: T) -> Result<Self>

Create a new Config instance by reading from a file

Arguments

• file_name - A file name (path) to read the configuration from

Returns

A Result containing the Config instance if successful, or an error

Examples found in repository

examples/data.rs (line 7)

async fn main() -> anyhow::Result<()> {
    tracing_subscriber::fmt::init();
    let config = Config::new("woo.toml")?;
    let client = ApiClient::new(&config)?;
    let data = client.list_all::<Data>().await?;
    info!("Got {} data", data.len());
    Ok(())
}

examples/customer.rs (line 8)

async fn main() -> anyhow::Result<()> {
    tracing_subscriber::fmt::init();
    let config = Config::new("woo.toml")?;
    let client = ApiClient::new(&config)?;
    let customers = client.list_all::<Customer>().await?;
    info!("Got {} customers", customers.len());
    let retrieved: Customer = client.retrieve(customers.first().unwrap().id).await?;
    info!("Retrieved customer name is {}", retrieved.first_name);
    Ok(())
}

examples/order.rs (line 9)

async fn main() -> anyhow::Result<()> {
    tracing_subscriber::fmt::init();
    let config = Config::new("woo.toml")?;
    let client = ApiClient::new(&config)?;
    let orders = client.list_all::<Order>().await?;
    info!("Got {} orders", orders.len());
    let random_order_id = orders.first().ok_or(anyhow!("Error"))?.id;
    let retrieved_order = client.retrieve::<Order>(random_order_id).await?;
    info!(
        "Got order with number: {} with total: {}",
        retrieved_order.number, retrieved_order.total
    );
    Ok(())
}

examples/category.rs (line 8)

async fn main() -> anyhow::Result<()> {
    tracing_subscriber::fmt::init();
    let config = Config::new("woo.toml")?;
    let client = ApiClient::new(&config)?;
    let categories = client.list_all::<Category>().await?;
    info!("Got {} categories", categories.len());
    let random_id = categories.first().unwrap().id;
    let retrieved: Category = client.retrieve(random_id).await?;
    info!("Retrieved category name: {}", retrieved.name);
    let create = Category::create("Test Category")
        .parent(retrieved.id)
        .description("Test description")
        .display(DisplayOption::Products)
        .image("https://woocommerce.github.io/woocommerce-rest-api-docs/images/logo-95f5c1ab.png");
    let batch_create = create.clone();
    let created: Category = client.create(create).await?;
    info!("Category with id: {} created", created.id);
    let update = Category::update().description("Some description");
    let updated: Category = client.update(created.id, update).await?;
    info!("New description is {}", updated.description);
    let deleted: Category = client.delete(updated.id).await?;
    info!("Category {} deleted", deleted.name);
    let batch_created: Vec<Category> = client.batch_create(vec![batch_create]).await?;
    info!("Batch created {} categories", batch_created.len());
    let batch_update = Category::update()
        .id(batch_created.first().unwrap().id)
        .description("Some description");
    let batch_updated: Vec<Category> = client.batch_update(vec![batch_update]).await?;
    let id = batch_updated.first().unwrap().id;
    info!("Batch updated categories contains category with id: {id}");
    let batch_deleted: Vec<Category> = client.batch_delete(vec![id]).await?;
    info!("Deleted {} categories", batch_deleted.len());
    Ok(())
}

examples/product.rs (line 8)

async fn main() -> Result<()> {
    tracing_subscriber::fmt::init();
    let config = Config::new("woo.toml")?;
    let client = ApiClient::new(&config)?;
    let start = std::time::Instant::now();
    let products = client.list_all::<Product>().await?;
    info!(
        "Got {} products in {} seconds",
        products.len(),
        start.elapsed().as_secs()
    );
    let random_id = products.first().map(|p| p.id).unwrap_or_default();
    let retrieved = client.retrieve::<Product>(random_id).await?;
    info!("Retrieved product has sku: {}", retrieved.sku);
    let attribute = Attribute::builder()
        .name("Test Attribute")
        .option("Best")
        .visible()
        .build();
    let new_product = Product::builder()
        .name("Test Product For Example")
        .featured()
        .short_description("The most professional description")
        .sku("product for test 42")
        .regular_price("6969")
        .manage_stock()
        .stock_quantity(42)
        .weight("50")
        .dimensions("4", "3", "2")
        .shipping_class("large")
        .images("https://cs14.pikabu.ru/post_img/2021/06/27/7/1624794514137159585.jpg")
        .attribute(attribute)
        .build();
    let batch_create = vec![new_product.clone()];
    let created: Product = client.create(new_product).await?;
    info!("Create product {} with id: {}", created.name, created.id);
    let update = Product::builder().unfeatured().build();
    let updated: Product = client.update(created.id, update).await?;
    info!(
        "Update product {}, new feature is {}",
        updated.name, updated.featured
    );
    let deleted: Product = client.delete(updated.id).await?;
    info!("Product {} deleted", deleted.name);
    let batch_created: Vec<Product> = client.batch_create(batch_create).await?;
    let id = batch_created.first().ok_or(anyhow!("Error"))?.id;
    let batch_update = Product::builder().id(id).unfeatured().build();
    let _batch_updated: Vec<Product> = client.batch_update(vec![batch_update]).await?;
    let _deleted: Product = client.delete(id).await?;
    Ok(())
}

examples/variation.rs (line 12)

async fn main() -> Result<()> {
    tracing_subscriber::fmt::init();
    let config = Config::new("woo.toml")?;
    let client = ApiClient::new(&config)?;
    let products = client.list_all::<Product>().await?;
    let random_variable_id = products
        .iter()
        .find(|p| !p.variations.is_empty())
        .map(|p| p.id)
        .unwrap_or_default();
    let variations = client
        .list_all_subentities::<ProductVariation>(random_variable_id)
        .await?;
    info!(
        "Got {} variations for product with id: {random_variable_id}",
        variations.len()
    );
    let retrieved_variation: ProductVariation = client
        .retrieve_subentity(
            random_variable_id,
            variations.first().map(|v| v.id).unwrap_or_default(),
        )
        .await?;
    info!("Retrieved variation has sku: {}", retrieved_variation.sku);
    let attribute = Attribute::builder()
        .name("Test Attribute")
        .option("Best")
        .option("Test")
        .variation()
        .visible()
        .build();
    let new_variable_product = Product::builder()
        .name("Test Product For Example")
        .product_type(ProductType::Variable)
        .featured()
        .short_description("The most professional description")
        .sku("product for test 42")
        .regular_price("6969")
        .manage_stock()
        .stock_quantity(42)
        .weight("50")
        .dimensions("4", "3", "2")
        .shipping_class("large")
        .images("https://cs14.pikabu.ru/post_img/2021/06/27/7/1624794514137159585.jpg")
        .attribute(attribute)
        .build();
    let created: Product = client.create(new_variable_product).await?;
    info!("Create product {} with id: {}", created.name, created.id);

    let variation = ProductVariation::builder()
        .sku(format!("{} Best", created.sku))
        .regular_price("6969")
        .manage_stock()
        .stock_quantity(96)
        .weight("52")
        .dimensions("5", "4", "3")
        .attribute(None, "Test Attribute", "Best")
        .build();
    let batch_create_variation = vec![variation.clone()];
    let created_variation: ProductVariation =
        client.create_subentity(created.id, variation).await?;
    info!(
        "Variation {} created with price: {}",
        created_variation.sku, created_variation.price
    );
    let update = ProductVariation::builder().regular_price("7000").build();
    let updated_variation: ProductVariation = client
        .update_subentity(created.id, created_variation.id, update)
        .await?;
    info!(
        "Variation {} updated with price: {}",
        updated_variation.sku, updated_variation.price
    );
    let deleted_variation: ProductVariation = client
        .delete_subentity(created.id, updated_variation.id)
        .await?;
    info!("Variation {} deleted", deleted_variation.sku);
    let batch_created_variation: Vec<ProductVariation> = client
        .batch_create_subentity(created.id, batch_create_variation)
        .await?;
    let bcv_id = batch_created_variation
        .first()
        .map(|v| v.id)
        .unwrap_or_default();
    let batch_update_variation = vec![ProductVariation::builder()
        .id(bcv_id)
        .regular_price("777")
        .build()];
    let _batch_updated_variation: Vec<ProductVariation> = client
        .batch_update_subentity(created.id, batch_update_variation)
        .await?;
    let _batch_deleted_variation: Vec<ProductVariation> = client
        .batch_delete_subentity(created.id, vec![bcv_id])
        .await?;
    let deleted: Product = client.delete(created.id).await?;
    info!("Product {} deleted", deleted.name);
    Ok(())
}

Trait Implementations

impl<'de> Deserialize<'de> for Config

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.