Updating resources

Updating a product

You can update a product's labels via key-value pairs, such as "style=womens" or "onSale=true", using the following code.

Command-line

To update a product, send a PATCH request to the following URI.
  • Replace project-id with the id of your Google Cloud Platform (GCP) project.
  • Replace location-id with a valid location identifier. Valid location identifiers are: us-west1, us-east1, europe-west1, and asia-east1
  • Replace product-id with the id for the product to update.
curl -X PATCH \
-H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "Content-Type: application/json" \
https://vision.googleapis.com/v1/projects/project-id/locations/location-id/products/product-id -d "{
   'updateMask': { 'paths': ['display_name'] },
   'product': { 'display_name': 'new-display-name' }
}"

C#

private static int UpdateProductLabels(UpdateProductLabelsOptions opts)
{
    var client = ProductSearchClient.Create();
    var request = new UpdateProductRequest
    {
        Product = new Product
        {
            // Get the name of the product
            ProductName = new ProductName(opts.ProjectID,
                                         opts.ComputeRegion,
                                         opts.ProductID),
            // Set the product name, product label, and product display
            // name. Multiple labels are also supported.
            ProductLabels =
            {
                new Product.Types.KeyValue
                {
                    Key = opts.Labels.Split(",").First(),
                    Value = opts.Labels.Split(",").Last()
                }
            }
        },
        // Updating only the product_labels field here.
        UpdateMask = new FieldMask
        {
            Paths = { "product_labels" }
        }
    };

    // This overwrites the product_labels.
    var product = client.UpdateProduct(request);

    var productId = product.Name.Split("/").Last();
    Console.WriteLine($"\nProduct name: {product.Name}");
    Console.WriteLine($"Product id: {productId}");
    Console.WriteLine($"Product display name: {product.DisplayName}");
    Console.WriteLine($"Product category: {product.ProductCategory}");
    Console.WriteLine($"Product labels:");
    foreach (var label in product.ProductLabels)
    {
        Console.WriteLine($"\tLabel: {label.ToString()}");
    }
    return 0;
}

Go


import (
	"context"
	"fmt"
	"io"

	vision "cloud.google.com/go/vision/apiv1"
	visionpb "google.golang.org/genproto/googleapis/cloud/vision/v1"
	field_mask "google.golang.org/genproto/protobuf/field_mask"
)

// updateProductLabels updates product labels of a product.
func updateProductLabels(w io.Writer, projectID string, location string, productID string, key string, value string) error {
	ctx := context.Background()
	c, err := vision.NewProductSearchClient(ctx)
	if err != nil {
		return fmt.Errorf("NewProductSearchClient: %v", err)
	}
	defer c.Close()

	req := &visionpb.UpdateProductRequest{
		UpdateMask: &field_mask.FieldMask{
			Paths: []string{
				"product_labels",
			},
		},
		Product: &visionpb.Product{
			Name: fmt.Sprintf("projects/%s/locations/%s/products/%s", projectID, location, productID),
			ProductLabels: []*visionpb.Product_KeyValue{
				{
					Key:   key,
					Value: value,
				},
			},
		},
	}

	resp, err := c.UpdateProduct(ctx, req)
	if err != nil {
		return fmt.Errorf("UpdateProduct: %v", err)
	}

	fmt.Fprintf(w, "Product name: %s\n", resp.Name)
	fmt.Fprintf(w, "Updated product labels: %s\n", resp.ProductLabels)

	return nil
}

Java

/**
 * Update the product labels.
 *
 * @param projectId - Id of the project.
 * @param computeRegion - Region name.
 * @param productId -Id of the product.
 * @param productLabels - Labels of the product.
 * @throws IOException - on I/O errors.
 */
public static void updateProductLabels(
    String projectId, String computeRegion, String productId, String productLabels)
    throws IOException {
  try (ProductSearchClient client = ProductSearchClient.create()) {

    // Get the full path of the product.
    String formattedName =
        ProductSearchClient.formatProductName(projectId, computeRegion, productId);

    // Set product name, product labels and product display name.
    // Multiple labels are also supported.
    Product product =
        Product.newBuilder()
            .setName(formattedName)
            .addProductLabels(
                KeyValue.newBuilder()
                    .setKey(productLabels.split(",")[0].split("=")[0])
                    .setValue(productLabels.split(",")[0].split("=")[1])
                    .build())
            .build();

    // Set product update field name.
    FieldMask updateMask = FieldMask.newBuilder().addPaths("product_labels").build();

    // Update the product.
    Product updatedProduct = client.updateProduct(product, updateMask);
    // Display the product information
    System.out.println(String.format("Product name: %s", updatedProduct.getName()));
    System.out.println(String.format("Updated product labels: "));
    for (Product.KeyValue element : updatedProduct.getProductLabelsList()) {
      System.out.println(String.format("%s: %s", element.getKey(), element.getValue()));
    }
  }
}

Node.js

async function updateProductLabels() {
  // Imports the Google Cloud client library
  const vision = require('@google-cloud/vision');

  // Creates a client
  const client = new vision.ProductSearchClient();

  /**
   * TODO(developer): Uncomment the following line before running the sample.
   */
  // const projectId = 'Your Google Cloud project Id';
  // const location = 'A compute region name';
  // const productId = 'Id of the product';
  // const key = 'The key of the label';
  // const value = 'The value of the label';

  // Resource path that represents full path to the product.
  const productPath = client.productPath(projectId, location, productId);

  const product = {
    name: productPath,
    productLabels: [
      {
        key: key,
        value: value,
      },
    ],
  };

  const updateMask = {
    paths: ['product_labels'],
  };

  const request = {
    product: product,
    updateMask: updateMask,
  };

  const [updatedProduct] = await client.updateProduct(request);
  console.log(`Product name: ${updatedProduct.name}`);
  console.log(`Product display name: ${updatedProduct.displayName}`);
  console.log(`Product description: ${updatedProduct.description}`);
  console.log(`Product category: ${updatedProduct.productCategory}`);
  console.log(
    `Product Labels: ${updatedProduct.productLabels[0].key}: ${updatedProduct.productLabels[0].value}`
  );
}

PHP

namespace Google\Cloud\Samples\Vision;

use Google\Cloud\Vision\V1\ProductSearchClient;
use Google\Cloud\Vision\V1\Product\KeyValue;
use Google\Cloud\Vision\V1\Product;
use Google\Protobuf\FieldMask;

/**
 * Update product labels
 *
 * @param string $projectId Your Google Cloud project ID
 * @param string $location Google Cloud compute region name
 * @param string $productId ID of the product
 * @param string $key Key of the label to update
 * @param string $value Value of label to update
 */
function product_update($projectId, $location, $productId, $key, $value)
{
    $client = new ProductSearchClient();

    # get the name of the product.
    $productPath = $client->productName($projectId, $location, $productId);

    # set product name, product label and product display name.
    # multiple labels are also supported.
    $keyValue = (new KeyValue())
        ->setKey($key)
        ->setValue($value);
    $product = (new Product())
        ->setName($productPath)
        ->setProductLabels([$keyValue]);

    # updating only the product labels field here.
    $updateMask = (new FieldMask())
        ->setPaths(['product_labels']);

    # this overwrites the product_labels.
    $updatedProduct = $client->updateProduct($product, ['updateMask' => $updateMask]);

    # display the product information.
    printf('Product name: %s' . PHP_EOL, $updatedProduct->getName());
    print('Product labels: ' . PHP_EOL);
    foreach ($product->getProductLabels() as $label) {
        printf('%s : %s' . PHP_EOL, $label->getKey(), $label->getValue());
    }

    $client->close();
}

Python

from google.cloud import vision

def update_product_labels(
        project_id, location, product_id, key, value):
    """Update the product labels.
    Args:
        project_id: Id of the project.
        location: A compute region name.
        product_id: Id of the product.
        key: The key of the label.
        value: The value of the label.
    """
    client = vision.ProductSearchClient()

    # Get the name of the product.
    product_path = client.product_path(
        project=project_id, location=location, product=product_id)

    # Set product name, product label and product display name.
    # Multiple labels are also supported.
    key_value = vision.types.Product.KeyValue(key=key, value=value)
    product = vision.types.Product(
        name=product_path,
        product_labels=[key_value])

    # Updating only the product_labels field here.
    update_mask = vision.types.FieldMask(paths=['product_labels'])

    # This overwrites the product_labels.
    updated_product = client.update_product(
        product=product, update_mask=update_mask)

    # Display the updated product information.
    print('Product name: {}'.format(updated_product.name))
    print('Updated product labels: {}'.format(product.product_labels))

Ruby

require "google/cloud/vision"

def product_search_update_product_labels project_id = "your-project-id",
                                         location   = "us-west1",
                                         product_id = "your-product-id"

  client = Google::Cloud::Vision.product_search

  product_path = client.product_path project:  project_id,
                                     location: location,
                                     product:  product_id
  product = {
    name:           product_path,
    product_labels: [{ key: "color", value: "green" }]
  }

  client.update_product product:     product,
                        update_mask: { "paths": ["product_labels"] }
end