MC-15986: Category Filtering

- Handle match filters

Author: danielrenaud

app/code/Magento/CatalogGraphQl/Model/Category/CategoryFilter.php

@@ -8,73 +8,95 @@
 namespace Magento\CatalogGraphQl\Model\Category;
 
 use Magento\Catalog\Api\Data\CategoryInterface;
-use Magento\Catalog\Model\ResourceModel\Category\CollectionFactory;
 use Magento\Catalog\Model\ResourceModel\Category\Collection;
+use Magento\Framework\App\Config\ScopeConfigInterface;
+use Magento\Framework\Exception\InputException;
+use Magento\Store\Api\Data\StoreInterface;
+use Magento\Store\Model\ScopeInterface;
+use Magento\Search\Model\Query;
 
 /**
  * Category filter allows to filter collection using 'id, url_key, name' from search criteria.
  */
 class CategoryFilter
 {
     /**
-     * @var CollectionFactory
+     * @var ScopeConfigInterface
      */
-    private $collectionFactory;
+    private $scopeConfig;
 
     /**
-     * @param CollectionFactory $collectionFactory
+     * @param ScopeConfigInterface $scopeConfig
      */
     public function __construct(
-        CollectionFactory $collectionFactory
+        ScopeConfigInterface $scopeConfig
     ) {
-        $this->collectionFactory = $collectionFactory;
+        $this->scopeConfig = $scopeConfig;
     }
 
     /**
      * Filter for filtering the requested categories id's based on url_key, ids, name in the result.
      *
      * @param array $args
      * @param Collection $categoryCollection
+     * @param StoreInterface $store
+     * @throws InputException
      */
-    public function applyFilters(
-        array $args,
-        Collection $categoryCollection
-    ): void {
+    public function applyFilters(array $args, Collection $categoryCollection, StoreInterface $store)
+    {
         $categoryCollection->addAttributeToFilter(CategoryInterface::KEY_IS_ACTIVE, ['eq' => 1]);
         foreach ($args['filters'] as $field => $cond) {
             foreach ($cond as $condType => $value) {
                 if ($field === 'ids') {
                     $categoryCollection->addIdFilter($value);
                 } else {
-                    $this->addAttributeFilter($categoryCollection, $field, $condType, $value);
+                    $this->addAttributeFilter($categoryCollection, $field, $condType, $value, $store);
                 }
             }
         }
     }
 
     /**
+     * Add filter to category collection
+     *
      * @param Collection $categoryCollection
      * @param string $field
      * @param string $condType
      * @param string|array $value
+     * @param StoreInterface $store
+     * @throws InputException
      */
-    private function addAttributeFilter($categoryCollection, $field, $condType, $value)
+    private function addAttributeFilter($categoryCollection, $field, $condType, $value, $store)
     {
         if ($condType === 'match') {
-            $this->addMatchFilter($categoryCollection, $field, $value);
+            $this->addMatchFilter($categoryCollection, $field, $value, $store);
             return;
         }
         $categoryCollection->addAttributeToFilter($field, [$condType => $value]);
     }
 
     /**
+     * Add match filter to collection
      *
      * @param Collection $categoryCollection
      * @param string $field
      * @param string $value
+     * @param StoreInterface $store
+     * @throws InputException
      */
-    private function addMatchFilter($categoryCollection, $field, $value)
+    private function addMatchFilter($categoryCollection, $field, $value, $store)
     {
-        $categoryCollection->addAttributeToFilter($field, ['like' => "%{$value}%"]);
+        $minQueryLength = $this->scopeConfig->getValue(
+            Query::XML_PATH_MIN_QUERY_LENGTH,
+            ScopeInterface::SCOPE_STORE,
+            $store
+        );
+        $searchValue = str_replace('%', '', $value);
+        $matchLength = strlen($searchValue);
+        if ($matchLength < $minQueryLength) {
+            throw new InputException(__('Invalid match filter'));
+        }
+
+        $categoryCollection->addAttributeToFilter($field, ['like' => "%{$searchValue}%"]);
     }
 }

app/code/Magento/CatalogGraphQl/Model/Resolver/CategoryList.php

@@ -7,8 +7,8 @@
 
 namespace Magento\CatalogGraphQl\Model\Resolver;
 
-use Magento\CatalogGraphQl\Model\Resolver\Category\CheckCategoryIsActive;
 use Magento\CatalogGraphQl\Model\Resolver\Products\DataProvider\ExtractDataFromCategoryTree;
+use Magento\Framework\Exception\InputException;
 use Magento\Framework\GraphQl\Config\Element\Field;
 use Magento\Framework\GraphQl\Exception\GraphQlNoSuchEntityException;
 use Magento\Framework\GraphQl\Query\ResolverInterface;
@@ -42,28 +42,20 @@ class CategoryList implements ResolverInterface
      */
     private $extractDataFromCategoryTree;
 
-    /**
-     * @var CheckCategoryIsActive
-     */
-    private $checkCategoryIsActive;
-
     /**
      * @param CategoryTree $categoryTree
      * @param ExtractDataFromCategoryTree $extractDataFromCategoryTree
-     * @param CheckCategoryIsActive $checkCategoryIsActive
      * @param CategoryFilter $categoryFilter
      * @param CollectionFactory $collectionFactory
      */
     public function __construct(
         CategoryTree $categoryTree,
         ExtractDataFromCategoryTree $extractDataFromCategoryTree,
-        CheckCategoryIsActive $checkCategoryIsActive,
         CategoryFilter $categoryFilter,
         CollectionFactory $collectionFactory
     ) {
         $this->categoryTree = $categoryTree;
         $this->extractDataFromCategoryTree = $extractDataFromCategoryTree;
-        $this->checkCategoryIsActive = $checkCategoryIsActive;
         $this->categoryFilter = $categoryFilter;
         $this->collectionFactory = $collectionFactory;
     }
@@ -76,25 +68,47 @@ public function resolve(Field $field, $context, ResolveInfo $info, array $value
         if (isset($value[$field->getName()])) {
             return $value[$field->getName()];
         }
-        $categoryCollection = $this->collectionFactory->create();
+        $store = $context->getExtensionAttributes()->getStore();
 
+        $rootCategoryIds = [];
         if (!isset($args['filters'])) {
-            $rootCategoryIds = [(int)$context->getExtensionAttributes()->getStore()->getRootCategoryId()];
+            $rootCategoryIds[] = (int)$store->getRootCategoryId();
         } else {
-            $this->categoryFilter->applyFilters($args, $categoryCollection);
-            $rootCategoryIds = [];
+            $categoryCollection = $this->collectionFactory->create();
+            try {
+                $this->categoryFilter->applyFilters($args, $categoryCollection, $store);
+            } catch (InputException $e) {
+                return [];
+            }
+
             foreach ($categoryCollection as $category) {
                 $rootCategoryIds[] = (int)$category->getId();
             }
         }
-        $result = [];
-        foreach ($rootCategoryIds as $rootCategoryId) {
-            $categoryTree = $this->categoryTree->getTree($info, $rootCategoryId);
+
+        $result = $this->fetchCategories($rootCategoryIds, $info);
+        return $result;
+    }
+
+    /**
+     * Fetch category tree data
+     *
+     * @param array $categoryIds
+     * @param ResolveInfo $info
+     * @return array
+     * @throws GraphQlNoSuchEntityException
+     */
+    private function fetchCategories(array $categoryIds, ResolveInfo $info)
+    {
+        $fetchedCategories = [];
+        foreach ($categoryIds as $categoryId) {
+            $categoryTree = $this->categoryTree->getTree($info, $categoryId);
             if (empty($categoryTree)) {
                 throw new GraphQlNoSuchEntityException(__('Category doesn\'t exist'));
             }
-            $result[] = current($this->extractDataFromCategoryTree->execute($categoryTree));
+            $fetchedCategories[] = current($this->extractDataFromCategoryTree->execute($categoryTree));
         }
-        return $result;
+
+        return $fetchedCategories;
     }
 }