Struct ProductService 

pub struct ProductService { /* private fields */ }

Implements a client for the Vertex AI Search for commerce API.

Example

use google_cloud_gax::paginator::ItemPaginator as _;
    let client = ProductService::builder().build().await?;
    let parent = "parent_value";
    let mut list = client.list_products()
        .set_parent(parent)
        .by_item();
    while let Some(item) = list.next().await.transpose()? {
        println!("{:?}", item);
    }

Service Description

Service for ingesting Product information of the customer’s website.

Configuration

To configure ProductService use the with_* methods in the type returned by builder(). The default configuration should work for most applications. Common configuration changes include

• with_endpoint(): by default this client uses the global default endpoint (https://retail.googleapis.com). Applications using regional endpoints or running in restricted networks (e.g. a network configured override this default.
• with_credentials(): by default this client uses Application Default Credentials. Applications using custom authentication may need to override this default.

Pooling and Cloning

ProductService holds a connection pool internally, it is advised to create one and reuse it. You do not need to wrap ProductService in an Rc or Arc to reuse it, because it already uses an Arc internally.

Implementations

impl ProductService

pub fn builder() -> ClientBuilder

Returns a builder for ProductService.

let client = ProductService::builder().build().await?;

pub fn from_stub<T>(stub: T) -> Self

where T: ProductService + 'static,

Creates a new client from the provided stub.

The most common case for calling this function is in tests mocking the client’s behavior.

pub fn create_product(&self) -> CreateProduct

Creates a Product.

Example

use google_cloud_retail_v2::model::Product;
use google_cloud_retail_v2::Result;
async fn sample(
   client: &ProductService, parent: &str
) -> Result<()> {
    let response = client.create_product()
        .set_parent(parent)
        .set_product_id("product_id_value")
        .set_product(
            Product::new()/* set fields */
        )
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn get_product(&self) -> GetProduct

Gets a Product.

Example

use google_cloud_retail_v2::Result;
async fn sample(
   client: &ProductService, name: &str
) -> Result<()> {
    let response = client.get_product()
        .set_name(name)
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn list_products(&self) -> ListProducts

Gets a list of Products.

Example

use google_cloud_gax::paginator::ItemPaginator as _;
use google_cloud_retail_v2::Result;
async fn sample(
   client: &ProductService, parent: &str
) -> Result<()> {
    let mut list = client.list_products()
        .set_parent(parent)
        .by_item();
    while let Some(item) = list.next().await.transpose()? {
        println!("{:?}", item);
    }
    Ok(())
}

pub fn update_product(&self) -> UpdateProduct

Updates a Product.

Example

use google_cloud_wkt::FieldMask;
use google_cloud_retail_v2::model::Product;
use google_cloud_retail_v2::Result;
async fn sample(
   client: &ProductService, name: &str
) -> Result<()> {
    let response = client.update_product()
        .set_product(
            Product::new().set_name(name)/* set fields */
        )
        .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn delete_product(&self) -> DeleteProduct

Deletes a Product.

Example

use google_cloud_retail_v2::Result;
async fn sample(
   client: &ProductService, name: &str
) -> Result<()> {
    client.delete_product()
        .set_name(name)
        .send().await?;
    Ok(())
}

pub fn purge_products(&self) -> PurgeProducts

Permanently deletes all selected Products under a branch.

This process is asynchronous. If the request is valid, the removal will be enqueued and processed offline. Depending on the number of Products, this operation could take hours to complete. Before the operation completes, some Products may still be returned by ProductService.GetProduct or ProductService.ListProducts.

Depending on the number of Products, this operation could take hours to complete. To get a sample of Products that would be deleted, set PurgeProductsRequest.force to false.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_retail_v2::Result;
async fn sample(
   client: &ProductService
) -> Result<()> {
    let response = client.purge_products()
        /* set fields */
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn import_products(&self) -> ImportProducts

Bulk import of multiple Products.

Request processing may be synchronous. Non-existing items are created.

Note that it is possible for a subset of the Products to be successfully updated.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_retail_v2::Result;
async fn sample(
   client: &ProductService
) -> Result<()> {
    let response = client.import_products()
        /* set fields */
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn set_inventory(&self) -> SetInventory

Updates inventory information for a Product while respecting the last update timestamps of each inventory field.

This process is asynchronous and does not require the Product to exist before updating fulfillment information. If the request is valid, the update is enqueued and processed downstream. As a consequence, when a response is returned, updates are not immediately manifested in the Product queried by ProductService.GetProduct or ProductService.ListProducts.

When inventory is updated with ProductService.CreateProduct and ProductService.UpdateProduct, the specified inventory field value(s) overwrite any existing value(s) while ignoring the last update time for this field. Furthermore, the last update times for the specified inventory fields are overwritten by the times of the ProductService.CreateProduct or ProductService.UpdateProduct request.

If no inventory fields are set in CreateProductRequest.product, then any pre-existing inventory information for this product is used.

If no inventory fields are set in SetInventoryRequest.set_mask, then any existing inventory information is preserved.

Pre-existing inventory information can only be updated with ProductService.SetInventory, ProductService.AddFulfillmentPlaces, and ProductService.RemoveFulfillmentPlaces.

The returned Operations is obsolete after one day, and the [GetOperation][google.longrunning.Operations.GetOperation] API returns NOT_FOUND afterwards.

If conflicting updates are issued, the Operations associated with the stale updates are not marked as done until they are obsolete.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_retail_v2::Result;
async fn sample(
   client: &ProductService
) -> Result<()> {
    let response = client.set_inventory()
        /* set fields */
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn add_fulfillment_places(&self) -> AddFulfillmentPlaces

We recommend that you use the ProductService.AddLocalInventories method instead of the ProductService.AddFulfillmentPlaces method. ProductService.AddLocalInventories achieves the same results but provides more fine-grained control over ingesting local inventory data.

Incrementally adds place IDs to Product.fulfillment_info.place_ids.

This process is asynchronous and does not require the Product to exist before updating fulfillment information. If the request is valid, the update will be enqueued and processed downstream. As a consequence, when a response is returned, the added place IDs are not immediately manifested in the Product queried by ProductService.GetProduct or ProductService.ListProducts.

The returned Operations will be obsolete after 1 day, and [GetOperation][google.longrunning.Operations.GetOperation] API will return NOT_FOUND afterwards.

If conflicting updates are issued, the Operations associated with the stale updates will not be marked as done until being obsolete.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_retail_v2::Result;
async fn sample(
   client: &ProductService
) -> Result<()> {
    let response = client.add_fulfillment_places()
        /* set fields */
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn remove_fulfillment_places(&self) -> RemoveFulfillmentPlaces

We recommend that you use the ProductService.RemoveLocalInventories method instead of the ProductService.RemoveFulfillmentPlaces method. ProductService.RemoveLocalInventories achieves the same results but provides more fine-grained control over ingesting local inventory data.

Incrementally removes place IDs from a Product.fulfillment_info.place_ids.

This process is asynchronous and does not require the Product to exist before updating fulfillment information. If the request is valid, the update will be enqueued and processed downstream. As a consequence, when a response is returned, the removed place IDs are not immediately manifested in the Product queried by ProductService.GetProduct or ProductService.ListProducts.

The returned Operations will be obsolete after 1 day, and [GetOperation][google.longrunning.Operations.GetOperation] API will return NOT_FOUND afterwards.

If conflicting updates are issued, the Operations associated with the stale updates will not be marked as done until being obsolete.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_retail_v2::Result;
async fn sample(
   client: &ProductService
) -> Result<()> {
    let response = client.remove_fulfillment_places()
        /* set fields */
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn add_local_inventories(&self) -> AddLocalInventories

Updates local inventory information for a Product at a list of places, while respecting the last update timestamps of each inventory field.

This process is asynchronous and does not require the Product to exist before updating inventory information. If the request is valid, the update will be enqueued and processed downstream. As a consequence, when a response is returned, updates are not immediately manifested in the Product queried by ProductService.GetProduct or ProductService.ListProducts.

Local inventory information can only be modified using this method. ProductService.CreateProduct and ProductService.UpdateProduct has no effect on local inventories.

The returned Operations will be obsolete after 1 day, and [GetOperation][google.longrunning.Operations.GetOperation] API will return NOT_FOUND afterwards.

If conflicting updates are issued, the Operations associated with the stale updates will not be marked as done until being obsolete.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_retail_v2::Result;
async fn sample(
   client: &ProductService
) -> Result<()> {
    let response = client.add_local_inventories()
        /* set fields */
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn remove_local_inventories(&self) -> RemoveLocalInventories

Remove local inventory information for a Product at a list of places at a removal timestamp.

This process is asynchronous. If the request is valid, the removal will be enqueued and processed downstream. As a consequence, when a response is returned, removals are not immediately manifested in the Product queried by ProductService.GetProduct or ProductService.ListProducts.

Local inventory information can only be removed using this method. ProductService.CreateProduct and ProductService.UpdateProduct has no effect on local inventories.

The returned Operations will be obsolete after 1 day, and [GetOperation][google.longrunning.Operations.GetOperation] API will return NOT_FOUND afterwards.

If conflicting updates are issued, the Operations associated with the stale updates will not be marked as done until being obsolete.

Long running operations

This method is used to start, and/or poll a long-running Operation. The Working with long-running operations chapter in the user guide covers these operations in detail.

Example

use google_cloud_lro::Poller;
use google_cloud_retail_v2::Result;
async fn sample(
   client: &ProductService
) -> Result<()> {
    let response = client.remove_local_inventories()
        /* set fields */
        .poller().until_done().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn list_operations(&self) -> ListOperations

Provides the Operations service functionality in this service.

Example

use google_cloud_gax::paginator::ItemPaginator as _;
use google_cloud_retail_v2::Result;
async fn sample(
   client: &ProductService
) -> Result<()> {
    let mut list = client.list_operations()
        /* set fields */
        .by_item();
    while let Some(item) = list.next().await.transpose()? {
        println!("{:?}", item);
    }
    Ok(())
}

pub fn get_operation(&self) -> GetOperation

Provides the Operations service functionality in this service.

Example

use google_cloud_retail_v2::Result;
async fn sample(
   client: &ProductService
) -> Result<()> {
    let response = client.get_operation()
        /* set fields */
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

Trait Implementations

impl Clone for ProductService

fn clone(&self) -> ProductService

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProductService

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

Formats the value using the given formatter.