Skip to content
  • Documentation >
  • PIM (Product management) >
  • Product API

Product API

Products

Ibexa DXP's Product API provides two services for handling product information, which differ in function:

  • ProductServiceInterface is used to request product data
  • LocalProductServiceInterface is used to modify products

Product REST API

To learn how to load products using the REST API, see REST API reference.

Getting product information

Get an individual product by using the productService::getProduct() method:

1
2
3
        $product = $this->productService->getProduct($productCode);

        $output->writeln('Product with code ' . $product->getCode() . ' is ' . $product->getName());

Find multiple products with productService::findProducts(). Provide the method with optional filter, query or Sort Clauses.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
        $criteria = new Criterion\ProductType([$productType]);
        $sortClauses = [new SortClause\ProductName(ProductQuery::SORT_ASC)];

        $productQuery = new ProductQuery(null, $criteria, $sortClauses);

        $products = $this->productService->findProducts($productQuery);

        foreach ($products as $product) {
            $output->writeln($product->getName() . ' of type ' . $product->getProductType()->getName());
        }

Modifying products

To create, update and delete products, use the LocalProductServiceInterface.

1
2
3
4
        $productUpdateStruct = $this->localProductService->newProductUpdateStruct($product);
        $productUpdateStruct->setCode('NEWMODIFIEDPRODUCT');

        $this->localProductService->updateProduct($productUpdateStruct);

To create a product, use LocalProductService::newProductCreateStruct(). Provide the method with the product type object and the main language code. You also need to set (at least) the code for the product and the required Field of the underlying content type, name:

1
2
3
4
5
6
7
        $productType = $this->productTypeService->getProductType($productType);

        $createStruct = $this->localProductService->newProductCreateStruct($productType, 'eng-GB');
        $createStruct->setCode('NEWPRODUCT');
        $createStruct->setField('name', 'New Product');

        $this->localProductService->createProduct($createStruct);

To delete a product, use LocalProductService::deleteProduct():

1
        $this->localProductService->deleteProduct($product);

Product variants

You can access the variants of a product by using ProductServiceInterface::findProductVariants(). The method takes the product object and a ProductVariantQuery object as parameters.

A ProductVariantQuery lets you define the offset and limit of the variant query. The default offset is 0, and limit is 25.

1
2
3
        $variantQuery = new ProductVariantQuery(0, 5);

        $variants = $this->productService->findProductVariants($product, $variantQuery)->getVariants();

From a variant, you can access the attributes that are used to generate the variant by using ProductVariant::getDiscriminatorAttributes().

1
2
3
4
5
6
7
        foreach ($variants as $variant) {
            $output->writeln($variant->getName());
            $attributes = $variant->getDiscriminatorAttributes();
            foreach ($attributes as $attribute) {
                $output->writeln($attribute->getIdentifier() . ': ' . $attribute->getValue() . ' ');
            }
        }

Creating variants

To create a product variant, use LocalProductService::createProductVariants(). This method takes the product and an array of ProductVariantCreateStruct objects as parameters. ProductVariantCreateStruct specifies the attribute values and the code for the new variant.

1
2
3
4
5
6
        $variantCreateStructs = [
            new ProductVariantCreateStruct(['color' => 'oak', 'frame_color' => 'white'], 'DESK1'),
            new ProductVariantCreateStruct(['color' => 'white', 'frame_color' => 'black'], 'DESK2'),
        ];

        $this->localProductService->createProductVariants($product, $variantCreateStructs);

Product assets

You can get assets assigned to a product by using AssetServiceInterface.

Use AssetServiceInterface to get a single asset by providing the product object and the assets's ID as parameters:

1
2
        $singleAsset = $this->assetService->getAsset($product, '1');
        $output->writeln($singleAsset->getName());

To get all assets assigned to a product, use AssetServiceInterface::findAssets(). You can retrieve the tags (corresponding to attribute values) of assets with the getTags() method:

1
2
3
4
5
6
7
8
9
        $assetCollection = $this->assetService->findAssets($product);

        foreach ($assetCollection as $asset) {
            $output->writeln($asset->getIdentifier() . ': ' . $asset->getName());
            $tags = $asset->getTags();
            foreach ($tags as $tag) {
                $output->writeln($tag);
            }
        }

Product types

To work with product types, use ProductTypeServiceInterface.

Get a product type object by using ProductTypeServiceInterface::getProductType:

1
        $productType = $this->productTypeService->getProductType($productTypeIdentifier);

You can also get a list of product types with ProductTypeServiceInterface::findProductTypes:

1
2
3
4
5
        $productTypes = $this->productTypeService->findProductTypes();

        foreach ($productTypes as $productType) {
            $output->writeln($productType->getName() . ' with identifier ' . $productType->getIdentifier());
        }

Product availability

Product availability is an object which defines whether a product is available, and if so, in what stock. To manage it, use ProductAvailabilityServiceInterface.

To check whether a product is available (with or without stock defined), use ProductAvailabilityServiceInterface::hasAvailability.

Get the availability object with getAvailability(). You can then use ProductAvailabilityServiceInterface::getStock to get the stock number for the product:

1
2
3
4
5
6
        if ($this->productAvailabilityService->hasAvailability($product)) {
            $availability = $this->productAvailabilityService->getAvailability($product);

            $output->write($availability->isAvailable() ? 'Available' : 'Unavailable');
            $output->writeln(' with stock ' . $availability->getStock());
        }

To change availability for a product, use updateProductAvailability() with a ProductAvailabilityUpdateStruct and provide it with the product object. The second parameter defines whether product is available, and the third whether its stock is infinite. The fourth parameter is the stock number:

1
2
3
            $productAvailabilityUpdateStruct = new ProductAvailabilityUpdateStruct($product, true, false, 80);

            $this->productAvailabilityService->updateProductAvailability($productAvailabilityUpdateStruct);

Attributes

To get information about product attribute groups, use the AttributeGroupServiceInterface, or LocalAttributeGroupServiceInterface to modify attribute groups.

AttributeGroupServiceInterface::getAttributeGroup() enables you to get a single attribute group by its identifier. AttributeGroupServiceInterface::findAttributeGroups() get all attribute groups, base on optional query:

1
2
3
4
5
6
7
        $attributeGroup = $this->attributeGroupService->getAttributeGroup('dimensions');

        $attributeGroups = $this->attributeGroupService->findAttributeGroups();

        foreach ($attributeGroups as $attributeGroup) {
            $output->writeln('Attribute group ' . $attributeGroup->getIdentifier() . ' with name ' . $attributeGroup->getName());
        }

To create an attribute group, use LocalAttributeGroupServiceinterface::createAttributeGroup and provide it with an AttributeGroupCreateStruct:

1
2
3
4
        $attributeGroupCreateStruct = $this->localAttributeGroupService->newAttributeGroupCreateStruct('dimensions');
        $attributeGroupCreateStruct->setNames(['eng-GB' => 'Size']);

        $this->localAttributeGroupService->createAttributeGroup($attributeGroupCreateStruct);

To get information about product attributes, use the AttributeDefinitionServiceInterface, or LocalAttributeDefinitionServiceInterface to modify attributes.

1
2
        $attribute = $this->attributeDefinitionService->getAttributeDefinition('length');
        $output->writeln($attribute->getName());

To create an attribute, use LocalAttributeGroupServiceinterface::createAttributeDefinition and provide it with an AttributeDefinitionCreateStruct:

1
2
3
4
5
6
        $attributeCreateStruct = $this->localAttributeDefinitionService->newAttributeDefinitionCreateStruct('size');
        $attributeCreateStruct->setType($attributeType);
        $attributeCreateStruct->setName('eng-GB', 'Size');
        $attributeCreateStruct->setGroup($attributeGroup);

        $this->localAttributeDefinitionService->createAttributeDefinition($attributeCreateStruct);