Magento 2 REST API, Page 4 Category

To Get products list Through Magento 2 REST API is not a big deal when you develop any native application. Here I am going to explain how we can get all the products list using Magento 2 REST API.

Wishuscess_ProductList is a complete module that helps you to decide a custom web API route id and that route id we will use to call this Wishuscess_ProductList on the postman server to test our custom REST API to get the product list.

Magento 2 REST API TO GET Products List

Here we have to create two classes one is the product list interface and the second is the model product list repository which helps us to get the complete product list through API calls.

app/code/Wishusucess/ProductsList/registration.php

app/code/Wishusucess/ProductsList/etc/module.xml

app/code/Wishusucess/ProductsList/etc/di.xml

app/code/Wishusucess/ProductsList/etc/webapi.xml

app/code/Wishusucess/ProductsList/Api/ProductListInterface.php

app/code/Wishusucess/ProductsList/Model/ProductListRepository.php

Create Magento 2 Rest API GetProductsList

You have to create a separate module for it so then you can decide the rest web API route id and then that web API you have to call on your different server to get the product list data.

Step 1: Registration

app/code/Wishusucess/ProductsList/registration.php

<?php
/**
*
* Developer: Hemant Singh Magento 2x Developer
* Category: Wishusucess_ProductsList
* Website: http://www.wishusucess.com/
*/
\Magento\Framework\Component\ComponentRegistrar::register(
\Magento\Framework\Component\ComponentRegistrar::MODULE,
'Wishusucess_ProductsList',
__DIR__
);

Step 2: Module Information

app/code/Wishusucess/ProductsList/etc/module.xml

<?xml version="1.0"?>
<!--
/**
*
* Developer: Hemant Singh Magento 2x Developer
* Category: Wishusucess_Customer
* Website: http://www.wishusucess.com/
*/
-->
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:Module/etc/module.xsd">
<module name="Wishusucess_ProductsList" setup_version="1.0.0" />
</config>

Step 3: Dependency Injection

app/code/Wishusucess/ProductsList/etc/di.xml

<?xml version="1.0"?>
<!--
/**
*
* Developer: Hemant Singh Magento 2x Developer
* Category: Wishusucess_Customer
* Website: http://www.wishusucess.com/
*/
-->
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:ObjectManager/etc/config.xsd">
<preference for="Wishusucess\ProductsList\Api\ProductListInterface" type="Wishusucess\ProductsList\Model\ProductListRepository" />
</config>

Step 4: Create Route ID To GET Products List

app/code/Wishusucess/ProductsList/etc/webapi.xml

<?xml version="1.0"?>
<!--
/**
*
* Developer: Hemant Singh Magento 2x Developer
* Category: Wishusucess_Customer
* Website: http://www.wishusucess.com/
*/
-->
<routes xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Webapi:etc/webapi.xsd">
<route url="/V1/wishusucess/products" method="GET">
<service class="Wishusucess\ProductsList\Api\ProductListInterface" method="getList"/>
<resources>
<resource ref="Magento_Catalog::products"/>
</resources>
</route>
</routes>

Step 5: Create Model Repository Class

By using this repository class you will decide how you are going to receive or process the request. Suppose you are getting a request to give the product list based on the SKUs then you have to decide all those parameters here.

Here you can set the product links as well in all those products with cache images and we have also added a function to get the product based on the product by id so when you will hit the API with product id then you will get the result.

app/code/Wishusucess/ProductsList/Model/ProductListRepository.php

<?php
/**
*
* Developer: Hemant Singh Magento 2x Developer
* Category: Wishusucess_ProductsList
* Website: http://www.wishusucess.com/
*/
namespace Wishusucess\ProductsList\Model;
use Wishusucess\ProductsList\Api\ProductListInterface;

use Magento\Catalog\Api\Data\ProductExtension;
use Magento\Catalog\Api\Data\ProductInterface;
use Magento\Catalog\Model\Product\Gallery\MimeTypeExtensionMap;
use Magento\Catalog\Model\ResourceModel\Product\Collection;
use Magento\Eav\Model\Entity\Attribute\Exception as AttributeException;
use Magento\Framework\Api\Data\ImageContentInterfaceFactory;
use Magento\Framework\Api\ImageContentValidatorInterface;
use Magento\Framework\Api\ImageProcessorInterface;
use Magento\Framework\Api\SearchCriteria\CollectionProcessorInterface;
use Magento\Framework\DB\Adapter\ConnectionException;
use Magento\Framework\DB\Adapter\DeadlockException;
use Magento\Framework\DB\Adapter\LockWaitException;
use Magento\Framework\EntityManager\Operation\Read\ReadExtensions;
use Magento\Framework\Exception\CouldNotSaveException;
use Magento\Framework\Exception\InputException;
use Magento\Framework\Exception\LocalizedException;
use Magento\Framework\Exception\NoSuchEntityException;
use Magento\Framework\Exception\TemporaryState\CouldNotSaveException as TemporaryCouldNotSaveException;
use Magento\Framework\Exception\ValidatorException;
use Magento\Catalog\Model\Product;

/**
* Product Repository.
* @SuppressWarnings(PHPMD.CouplingBetweenObjects)
* @SuppressWarnings(PHPMD.TooManyFields)
*/
class ProductListRepository implements ProductListInterface
{
/**
* @var \Magento\Catalog\Api\ProductCustomOptionRepositoryInterface
*/
protected $optionRepository;

/**
* @var \Magento\Catalog\Model\ProductFactory
*/
protected $productFactory;

/**
* @var Product[]
*/
protected $instances = [];

/**
* @var Product[]
*/
protected $instancesById = [];

/**
* @var \Magento\Catalog\Controller\Adminhtml\Product\Initialization\Helper
*/
protected $initializationHelper;

/**
* @var \Magento\Catalog\Api\Data\ProductSearchResultsInterfaceFactory
*/
protected $searchResultsFactory;

/**
* @var \Magento\Framework\Api\SearchCriteriaBuilder
*/
protected $searchCriteriaBuilder;

/**
* @var \Magento\Framework\Api\FilterBuilder
*/
protected $filterBuilder;

/**
* @var \Magento\Catalog\Model\ResourceModel\Product\CollectionFactory
*/
protected $collectionFactory;

/**
* @var \Magento\Catalog\Model\ResourceModel\Product
*/
protected $resourceModel;

/**
* @var Product\Initialization\Helper\ProductLinks
*/
protected $linkInitializer;

/**
* @var Product\LinkTypeProvider
*/
protected $linkTypeProvider;

/**
* @var \Magento\Store\Model\StoreManagerInterface
*/
protected $storeManager;

/**
* @var \Magento\Catalog\Api\ProductAttributeRepositoryInterface
*/
protected $attributeRepository;

/**
* @var \Magento\Catalog\Api\ProductAttributeRepositoryInterface
*/
protected $metadataService;

/**
* @var \Magento\Framework\Api\ExtensibleDataObjectConverter
*/
protected $extensibleDataObjectConverter;

/**
* @var \Magento\Framework\Filesystem
*/
protected $fileSystem;

/**
* @deprecated
* @see \Magento\Catalog\Model\MediaGalleryProcessor
* @var ImageContentInterfaceFactory
*/
protected $contentFactory;

/**
* @deprecated
* @see \Magento\Catalog\Model\MediaGalleryProcessor
* @var ImageProcessorInterface
*/
protected $imageProcessor;

/**
* @var \Magento\Framework\Api\ExtensionAttribute\JoinProcessorInterface
*/
protected $extensionAttributesJoinProcessor;

/**
* @var ProductRepository\MediaGalleryProcessor
*/
protected $mediaGalleryProcessor;

/**
* @var CollectionProcessorInterface
*/
private $collectionProcessor;

/**
* @var int
*/
private $cacheLimit = 0;

/**
* @var \Magento\Framework\Serialize\Serializer\Json
*/
private $serializer;

/**
* @var ReadExtensions
*/
private $readExtensions;

/**
* ProductRepository constructor.
* @param \Magento\Catalog\Model\ProductFactory $productFactory
* @param \Magento\Catalog\Controller\Adminhtml\Product\Initialization\Helper $initializationHelper
* @param \Magento\Catalog\Api\Data\ProductSearchResultsInterfaceFactory $searchResultsFactory
* @param ResourceModel\Product\CollectionFactory $collectionFactory
* @param \Magento\Framework\Api\SearchCriteriaBuilder $searchCriteriaBuilder
* @param \Magento\Catalog\Api\ProductAttributeRepositoryInterface $attributeRepository
* @param ResourceModel\Product $resourceModel
* @param Product\Initialization\Helper\ProductLinks $linkInitializer
* @param Product\LinkTypeProvider $linkTypeProvider
* @param \Magento\Store\Model\StoreManagerInterface $storeManager
* @param \Magento\Framework\Api\FilterBuilder $filterBuilder
* @param \Magento\Catalog\Api\ProductAttributeRepositoryInterface $metadataServiceInterface
* @param \Magento\Framework\Api\ExtensibleDataObjectConverter $extensibleDataObjectConverter
* @param Product\Option\Converter $optionConverter
* @param \Magento\Framework\Filesystem $fileSystem
* @param ImageContentValidatorInterface $contentValidator
* @param ImageContentInterfaceFactory $contentFactory
* @param MimeTypeExtensionMap $mimeTypeExtensionMap
* @param ImageProcessorInterface $imageProcessor
* @param \Magento\Framework\Api\ExtensionAttribute\JoinProcessorInterface $extensionAttributesJoinProcessor
* @param CollectionProcessorInterface $collectionProcessor [optional]
* @param \Magento\Framework\Serialize\Serializer\Json|null $serializer
* @param int $cacheLimit [optional]
* @param ReadExtensions|null $readExtensions
* @SuppressWarnings(PHPMD.ExcessiveParameterList)
* @SuppressWarnings(PHPMD.UnusedFormalParameter)
*/
public function __construct(
\Magento\Catalog\Model\ProductFactory $productFactory,
\Magento\Catalog\Controller\Adminhtml\Product\Initialization\Helper $initializationHelper,
\Magento\Catalog\Api\Data\ProductSearchResultsInterfaceFactory $searchResultsFactory,
\Magento\Catalog\Model\ResourceModel\Product\CollectionFactory $collectionFactory,
\Magento\Framework\Api\SearchCriteriaBuilder $searchCriteriaBuilder,
\Magento\Catalog\Api\ProductAttributeRepositoryInterface $attributeRepository,
\Magento\Catalog\Model\ResourceModel\Product $resourceModel,
\Magento\Catalog\Model\Product\Initialization\Helper\ProductLinks $linkInitializer,
\Magento\Catalog\Model\Product\LinkTypeProvider $linkTypeProvider,
\Magento\Store\Model\StoreManagerInterface $storeManager,
\Magento\Framework\Api\FilterBuilder $filterBuilder,
\Magento\Catalog\Api\ProductAttributeRepositoryInterface $metadataServiceInterface,
\Magento\Framework\Api\ExtensibleDataObjectConverter $extensibleDataObjectConverter,
\Magento\Catalog\Model\Product\Option\Converter $optionConverter,
\Magento\Framework\Filesystem $fileSystem,
ImageContentValidatorInterface $contentValidator,
ImageContentInterfaceFactory $contentFactory,
MimeTypeExtensionMap $mimeTypeExtensionMap,
ImageProcessorInterface $imageProcessor,
\Magento\Framework\Api\ExtensionAttribute\JoinProcessorInterface $extensionAttributesJoinProcessor,
CollectionProcessorInterface $collectionProcessor = null,
\Magento\Framework\Serialize\Serializer\Json $serializer = null,
$cacheLimit = 1000,
ReadExtensions $readExtensions = null
) {
$this->productFactory = $productFactory;
$this->collectionFactory = $collectionFactory;
$this->initializationHelper = $initializationHelper;
$this->searchResultsFactory = $searchResultsFactory;
$this->searchCriteriaBuilder = $searchCriteriaBuilder;
$this->resourceModel = $resourceModel;
$this->linkInitializer = $linkInitializer;
$this->linkTypeProvider = $linkTypeProvider;
$this->storeManager = $storeManager;
$this->attributeRepository = $attributeRepository;
$this->filterBuilder = $filterBuilder;
$this->metadataService = $metadataServiceInterface;
$this->extensibleDataObjectConverter = $extensibleDataObjectConverter;
$this->fileSystem = $fileSystem;
$this->contentFactory = $contentFactory;
$this->imageProcessor = $imageProcessor;
$this->extensionAttributesJoinProcessor = $extensionAttributesJoinProcessor;
$this->collectionProcessor = $collectionProcessor ?: $this->getCollectionProcessor();
$this->serializer = $serializer ?: \Magento\Framework\App\ObjectManager::getInstance()
->get(\Magento\Framework\Serialize\Serializer\Json::class);
$this->cacheLimit = (int)$cacheLimit;
$this->readExtensions = $readExtensions ?: \Magento\Framework\App\ObjectManager::getInstance()
->get(ReadExtensions::class);
}

/**
* @inheritdoc
*/
public function get($sku, $editMode = false, $storeId = null, $forceReload = false)
{
$cacheKey = $this->getCacheKey([$editMode, $storeId]);
$cachedProduct = $this->getProductFromLocalCache($sku, $cacheKey);
if ($cachedProduct === null || $forceReload) {
$productId = $this->resourceModel->getIdBySku($sku);
if (!$productId) {
throw new NoSuchEntityException(__('Requested product doesn\'t exist'));
}

$product = $this->getById($productId, $editMode, $storeId, $forceReload);

$this->cacheProduct($cacheKey, $product);
$cachedProduct = $product;
}

return $cachedProduct;
}

/**
* @inheritdoc
*/
public function getById($productId, $editMode = false, $storeId = null, $forceReload = false)
{
$cacheKey = $this->getCacheKey([$editMode, $storeId]);
if (!isset($this->instancesById[$productId][$cacheKey]) || $forceReload) {
$product = $this->productFactory->create();
if ($editMode) {
$product->setData('_edit_mode', true);
}
if ($storeId !== null) {
$product->setData('store_id', $storeId);
}
$product->load($productId);
if (!$product->getId()) {
throw new NoSuchEntityException(__('Requested product doesn\'t exist'));
}
$this->cacheProduct($cacheKey, $product);
}

return $this->instancesById[$productId][$cacheKey];
}

/**
* Get key for cache
*
* @param array $data
* @return string
*/
protected function getCacheKey($data)
{
$serializeData = [];
foreach ($data as $key => $value) {
if (is_object($value)) {
$serializeData[$key] = $value->getId();
} else {
$serializeData[$key] = $value;
}
}
$serializeData = $this->serializer->serialize($serializeData);

return sha1($serializeData);
}

/**
* Add product to internal cache and truncate cache if it has more than cacheLimit elements.
*
* @param string $cacheKey
* @param ProductInterface $product
* @return void
*/
private function cacheProduct($cacheKey, ProductInterface $product)
{
$_imageHelper = \Magento\Framework\App\ObjectManager::getInstance()->get('Magento\Catalog\Helper\Image');
$image = $_imageHelper->init($product, 'thumbnail', ['type'=>'thumbnail'])->keepAspectRatio(true)->resize('200','200')->getUrl();
$product->setCustomAttribute('thumbnail', $image);

$this->instancesById[$product->getId()][$cacheKey] = $product;
$this->saveProductInLocalCache($product, $cacheKey);

if ($this->cacheLimit && count($this->instances) > $this->cacheLimit) {
$offset = round($this->cacheLimit / -2);
$this->instancesById = array_slice($this->instancesById, $offset, null, true);
$this->instances = array_slice($this->instances, $offset, null, true);
}
}

/**
* Merge data from DB and updates from request
*
* @param array $productData
* @param bool $createNew
* @return ProductInterface|Product
* @throws NoSuchEntityException
*/
protected function initializeProductData(array $productData, $createNew)
{
unset($productData['media_gallery']);
if ($createNew) {
$product = $this->productFactory->create();
$this->assignProductToWebsites($product);
if (isset($productData['price']) && !isset($productData['product_type'])) {
$product->setTypeId(Product\Type::TYPE_SIMPLE);
}
} else {
if (!empty($productData['id'])) {
unset($this->instancesById[$productData['id']]);
$product = $this->getById($productData['id']);
} else {
$this->removeProductFromLocalCache($productData['sku']);
$product = $this->get($productData['sku']);
}
}

foreach ($productData as $key => $value) {
$product->setData($key, $value);
}

return $product;
}

/**
* Assign product to websites.
*
* @param \Magento\Catalog\Model\Product $product
* @return void
*/
private function assignProductToWebsites(\Magento\Catalog\Model\Product $product)
{
if ($this->storeManager->getStore(true)->getCode() === \Magento\Store\Model\Store::ADMIN_CODE) {
$websiteIds = array_keys($this->storeManager->getWebsites());
} else {
$websiteIds = [$this->storeManager->getStore()->getWebsiteId()];
}

$product->setWebsiteIds($websiteIds);
}

/**
* Process product links, creating new links, updating and deleting existing links
*
* @param ProductInterface $product
* @param \Magento\Catalog\Api\Data\ProductLinkInterface[] $newLinks
* @return $this
* @throws NoSuchEntityException
*/
private function processLinks(ProductInterface $product, $newLinks)
{
if ($newLinks === null) {
// If product links were not specified, don't do anything
return $this;
}

// Clear all existing product links and then set the ones we want
$linkTypes = $this->linkTypeProvider->getLinkTypes();
foreach (array_keys($linkTypes) as $typeName) {
$this->linkInitializer->initializeLinks($product, [$typeName => []]);
}

// Set each linktype info
if (!empty($newLinks)) {
$productLinks = [];
foreach ($newLinks as $link) {
$productLinks[$link->getLinkType()][] = $link;
}

foreach ($productLinks as $type => $linksByType) {
$assignedSkuList = [];
/** @var \Magento\Catalog\Api\Data\ProductLinkInterface $link */
foreach ($linksByType as $link) {
$assignedSkuList[] = $link->getLinkedProductSku();
}
$linkedProductIds = $this->resourceModel->getProductsIdsBySkus($assignedSkuList);

$linksToInitialize = [];
foreach ($linksByType as $link) {
$linkDataArray = $this->extensibleDataObjectConverter
->toNestedArray($link, [], \Magento\Catalog\Api\Data\ProductLinkInterface::class);
$linkedSku = $link->getLinkedProductSku();
if (!isset($linkedProductIds[$linkedSku])) {
throw new NoSuchEntityException(
__('Product with SKU "%1" does not exist', $linkedSku)
);
}
$linkDataArray['product_id'] = $linkedProductIds[$linkedSku];
$linksToInitialize[$linkedProductIds[$linkedSku]] = $linkDataArray;
}

$this->linkInitializer->initializeLinks($product, [$type => $linksToInitialize]);
}
}

$product->setProductLinks($newLinks);

return $this;
}

/**
* @inheritdoc
* @SuppressWarnings(PHPMD.CyclomaticComplexity)
* @SuppressWarnings(PHPMD.NPathComplexity)
*/
public function save(ProductInterface $product, $saveOptions = false)
{
$tierPrices = $product->getData('tier_price');

try {
$existingProduct = $product->getId() ? $this->getById($product->getId()) : $this->get($product->getSku());

$product->setData(
$this->resourceModel->getLinkField(),
$existingProduct->getData($this->resourceModel->getLinkField())
);
if (!$product->hasData(Product::STATUS)) {
$product->setStatus($existingProduct->getStatus());
}

/** @var ProductExtension $extensionAttributes */
$extensionAttributes = $product->getExtensionAttributes();
if (empty($extensionAttributes->__toArray())) {
$product->setExtensionAttributes($existingProduct->getExtensionAttributes());
}
} catch (NoSuchEntityException $e) {
$existingProduct = null;
}

$productDataArray = $this->extensibleDataObjectConverter
->toNestedArray($product, [], ProductInterface::class);
$productDataArray = array_replace($productDataArray, $product->getData());
$ignoreLinksFlag = $product->getData('ignore_links_flag');
$productLinks = null;
if (!$ignoreLinksFlag && $ignoreLinksFlag !== null) {
$productLinks = $product->getProductLinks();
}
if (!isset($productDataArray['store_id'])) {
$productDataArray['store_id'] = (int)$this->storeManager->getStore()->getId();
}
$product = $this->initializeProductData($productDataArray, empty($existingProduct));

$this->processLinks($product, $productLinks);
if (isset($productDataArray['media_gallery_entries'])) {
$this->getMediaGalleryProcessor()->processMediaGallery(
$product,
$productDataArray['media_gallery_entries']
);
}

if (!$product->getOptionsReadonly()) {
$product->setCanSaveCustomOptions(true);
}

$validationResult = $this->resourceModel->validate($product);
if (true !== $validationResult) {
throw new \Magento\Framework\Exception\CouldNotSaveException(
__('Invalid product data: %1', implode(',', $validationResult))
);
}

if ($tierPrices !== null) {
$product->setData('tier_price', $tierPrices);
}

$this->saveProduct($product);
$this->removeProductFromLocalCache($product->getSku());
unset($this->instancesById[$product->getId()]);

return $this->get($product->getSku(), false, $product->getStoreId());
}

/**
* @inheritdoc
*/
public function delete(ProductInterface $product)
{
$sku = $product->getSku();
$productId = $product->getId();
try {
$this->removeProductFromLocalCache($product->getSku());
unset($this->instancesById[$product->getId()]);
$this->resourceModel->delete($product);
} catch (ValidatorException $e) {
throw new CouldNotSaveException(__($e->getMessage()));
} catch (\Exception $e) {
throw new \Magento\Framework\Exception\StateException(
__('Unable to remove product %1', $sku)
);
}
$this->removeProductFromLocalCache($sku);
unset($this->instancesById[$productId]);

return true;
}

/**
* @inheritdoc
*/
public function deleteById($sku)
{
$product = $this->get($sku);

return $this->delete($product);
}

/**
* @inheritdoc
*/
public function getList(\Magento\Framework\Api\SearchCriteriaInterface $searchCriteria)
{
/** @var \Magento\Catalog\Model\ResourceModel\Product\Collection $collection */
$collection = $this->collectionFactory->create();
$this->extensionAttributesJoinProcessor->process($collection);

$collection->addAttributeToSelect('*');
$collection->joinAttribute('status', 'catalog_product/status', 'entity_id', null, 'inner');
$collection->joinAttribute('visibility', 'catalog_product/visibility', 'entity_id', null, 'inner');
$collection->addMinimalPrice();//adding minmalprice you can change to addFinalPrice amjad fluxstore

$this->collectionProcessor->process($searchCriteria, $collection);

$collection->load();

$collection->addCategoryIds();
$this->addExtensionAttributes($collection);
$searchResult = $this->searchResultsFactory->create();
$searchResult->setSearchCriteria($searchCriteria);
$searchResult->setItems($collection->getItems());
$searchResult->setTotalCount($collection->getSize());

foreach ($collection->getItems() as $product) {
$this->cacheProduct(
$this->getCacheKey(
[
false,
$product->getStoreId()
]
),
$product
);
}

return $searchResult;
}

/**
* Add extension attributes to loaded items.
*
* @param Collection $collection
* @return Collection
*/
private function addExtensionAttributes(Collection $collection): Collection
{
foreach ($collection->getItems() as $item) {
$this->readExtensions->execute($item);
}

return $collection;
}

/**
* Helper function that adds a FilterGroup to the collection.
*
* @deprecated 101.1.0
* @param \Magento\Framework\Api\Search\FilterGroup $filterGroup
* @param Collection $collection
* @return void
*/
protected function addFilterGroupToCollection(
\Magento\Framework\Api\Search\FilterGroup $filterGroup,
Collection $collection
) {
$fields = [];
$categoryFilter = [];
foreach ($filterGroup->getFilters() as $filter) {
$conditionType = $filter->getConditionType() ?: 'eq';

if ($filter->getField() == 'category_id') {
$categoryFilter[$conditionType][] = $filter->getValue();
continue;
}
$fields[] = ['attribute' => $filter->getField(), $conditionType => $filter->getValue()];
}

if ($categoryFilter) {
$collection->addCategoriesFilter($categoryFilter);
}

if ($fields) {
$collection->addFieldToFilter($fields);
}
}

/**
* Clean internal product cache
*
* @return void
*/
public function cleanCache()
{
$this->instances = null;
$this->instancesById = null;
}

/**
* Retrieve media gallery processor.
*
* @return ProductRepository\MediaGalleryProcessor
*/
private function getMediaGalleryProcessor()
{
if (null === $this->mediaGalleryProcessor) {
$this->mediaGalleryProcessor = \Magento\Framework\App\ObjectManager::getInstance()
->get(ProductRepository\MediaGalleryProcessor::class);
}

return $this->mediaGalleryProcessor;
}

/**
* Retrieve collection processor
*
* @deprecated 101.1.0
* @return CollectionProcessorInterface
*/
private function getCollectionProcessor()
{
if (!$this->collectionProcessor) {
$this->collectionProcessor = \Magento\Framework\App\ObjectManager::getInstance()->get(
'Magento\Catalog\Model\Api\SearchCriteria\ProductCollectionProcessor'
);
}

return $this->collectionProcessor;
}

/**
* Gets product from the local cache by SKU.
*
* @param string $sku
* @param string $cacheKey
* @return Product|null
*/
private function getProductFromLocalCache(string $sku, string $cacheKey)
{
$preparedSku = $this->prepareSku($sku);
if (!isset($this->instances[$preparedSku])) {
return null;
}

return $this->instances[$preparedSku][$cacheKey] ?? null;
}

/**
* Removes product in the local cache.
*
* @param string $sku
* @return void
*/
private function removeProductFromLocalCache(string $sku)
{
$preparedSku = $this->prepareSku($sku);
unset($this->instances[$preparedSku]);
}

/**
* Saves product in the local cache.
*
* @param Product $product
* @param string $cacheKey
*/
private function saveProductInLocalCache(Product $product, string $cacheKey)
{
$preparedSku = $this->prepareSku($product->getSku());
$this->instances[$preparedSku][$cacheKey] = $product;
}

/**
* Converts SKU to lower case and trims.
*
* @param string $sku
* @return string
*/
private function prepareSku(string $sku): string
{
return mb_strtolower(trim($sku));
}

/**
* Save product resource model.
*
* @param ProductInterface|Product $product
* @throws TemporaryCouldNotSaveException
* @throws InputException
* @throws CouldNotSaveException
* @throws LocalizedException
*/
private function saveProduct($product)
{
try {
$this->removeProductFromLocalCache($product->getSku());
unset($this->instancesById[$product->getId()]);
$this->resourceModel->save($product);
} catch (ConnectionException $exception) {
throw new TemporaryCouldNotSaveException(
__('Database connection error'),
$exception,
$exception->getCode()
);
} catch (DeadlockException $exception) {
throw new TemporaryCouldNotSaveException(
__('Database deadlock found when trying to get lock'),
$exception,
$exception->getCode()
);
} catch (LockWaitException $exception) {
throw new TemporaryCouldNotSaveException(
__('Database lock wait timeout exceeded'),
$exception,
$exception->getCode()
);
} catch (AttributeException $exception) {
throw InputException::invalidFieldValue(
$exception->getAttributeCode(),
$product->getData($exception->getAttributeCode()),
$exception
);
} catch (ValidatorException $e) {
throw new CouldNotSaveException(__($e->getMessage()));
} catch (LocalizedException $e) {
throw $e;
} catch (\Exception $e) {
throw new CouldNotSaveException(__('Unable to save product'), $e);
}
}
}

Step 6: API Class GET Products List Interface

So, here you have to create a function getList() that will have some search criteria as a parameter and when you will give that parameter and then send a request then Magento 2 will ask you to authorize first so you have to send with an admin token then Magento 2 website will give you the products list.

app/code/Wishusucess/ProductsList/Api/ProductListInterface.php

<?php
/**
*
* Developer: Hemant Singh Magento 2x Developer
* Category: Wishusucess_Customer
* Website: http://www.wishusucess.com/
*/
namespace Wishusucess\ProductsList\Api;
/**
* @api
*/
interface ProductListInterface
{
/**
* Get product list
*
* @param \Magento\Framework\Api\SearchCriteriaInterface $searchCriteria
* @return \Magento\Catalog\Api\Data\ProductSearchResultsInterface
*/
public function getList(\Magento\Framework\Api\SearchCriteriaInterface $searchCriteria);
}

Now, Run The Following command:

php bin/magento s:up

php bin/magento s:s:d -f

php bin/magento c:c

Now, we have created our Magento 2 product list rest API, so in order to use this API we have to create an admin token first then we have to use that token and send the request in the below format.

https://www.wishusucess.com/rest/store_id/V1/wishusucess/products

With Get method when you will send the request in above format of URL then you will get the product list data.

Download ProductsList API

Recommended Post:

Magento 2 Customer API: Create Custom API For Customer

ContactUs REST API: Create Magento 2 Custom Contact Us REST API