DanielSousa\UrlRewrite\Console\Command\Products

Complexity

Total Complexity

31

Size/Duplication

Total Lines	292
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	5
Bugs	1	Features	5

14 Methods

Rating	Name	Duplication	Size	Complexity
A	configure()	0	22	1
A	execute()	0	23	3
B	callbackGenerateProductUrl()	0	29	4
A	removeProductUrls()	0	21	3
A	prepareUrls()	0	4	1
A	getProductUrlRewriteGenerator()	0	4	1
A	prepareCollections()	0	21	4
A	getProductCollection()	0	8	2
A	addFilterProductIds()	0	7	3
A	addStoreFilter()	0	9	3
A	addCollections()	0	4	1
A	getSizeToProcess()	0	8	2
A	rebuildUrls()	0	14	2
A	getProductFactory()	0	4	1

<?php
/**
 * Rebuild Url Rewrite for magento 2
 * Copyright (C) 2017
 *
 * This file is part of DanielSousa/UrlRewrite.
 *
 * DanielSousa/UrlRewrite is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

namespace DanielSousa\UrlRewrite\Console\Command;

use Magento\UrlRewrite\Service\V1\Data\UrlRewrite;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

class Products extends AbstractUrlRewriteCommand
{

    /**
     * Name of product input option
     */
    const INPUT_PRODUCT = 'product';

    /**
     * Force of force input option
     */
    const INPUT_FORCE = 'force';

    /**
     * Name of product input option
     */
    const INPUT_STORE = 'store';

    /**
     * @var \Magento\Catalog\Model\ResourceModel\Product\Collection
     */
    protected $_collection = null;

    /**
     * Collections to process
     */
    protected $_collections = [];


    /**
     * {@inheritdoc}
     */
    protected function configure()
    {
        $options = [
            new InputOption(
                self::INPUT_PRODUCT,
                'p',
                InputOption::VALUE_OPTIONAL,
                'Reindex a specific product'
            ),
            new InputOption(
                self::INPUT_STORE,
                's',
                InputOption::VALUE_OPTIONAL,
                'Reindex a specific store',
                \Magento\Store\Model\Store::DEFAULT_STORE_ID
            )
        ];
        $this->setName('urlrewrite:rebuild:products');
        $this->setDescription('Rebuild Product URL Rewrites');
        $this->setDefinition($options);
        parent::configure();
    }

    /**
     * {@inheritdoc}
     */
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        parent::execute($input, $output);

        try {

            $productIds = $input->getOption(self::INPUT_PRODUCT);
            $storeId = $input->getOption(self::INPUT_STORE);
            $this->prepareCollections($storeId, $productIds);

            if ($size = $this->getSizeToProcess()) {
                $this->progressBar->start($size);
                $this->rebuildUrls();
            }

            $this->progressBar->finish();
            $this->output->write('', true);
        } catch (\Exception $e) {
            $this->output->writeln($e->getMessage());
            return \Magento\Framework\Console\Cli::RETURN_FAILURE;
        }
        return \Magento\Framework\Console\Cli::RETURN_SUCCESS;
    }

    /**
     * Generate product url by product
     * @param $args
     */
    public function callbackGenerateProductUrl($args)
    {
        try {
            if (!isset($args['row']['entity_id'])) {
                $this->output->writeln('Id not found');
                return;
            }
            $productId = $args['row']['entity_id'];
            $this->progressBar->setMessage($productId);
            $this->progressBar->advance();


            $product = clone $args['product'];
            $product->load($productId);

            $storeId = $args['storeId'];
            if (is_null($storeId)) {
                $storeId = \Magento\Store\Model\Store::DEFAULT_STORE_ID;
            }
            $product->setStoreId($storeId);
            $this->removeProductUrls($productId, $storeId);
            $this->replaceUrls(
                $this->prepareUrls($product)
            );
        } catch (\Exception $e) {
            $this->output->writeln($e->getMessage() . '- Product ID -' . $productId);

The variable $productId does not seem to be defined for all execution paths leading up to this point.

            return;
        }
    }

    /**
     *  Remove Product urls
     *
     * @param $productId
     * @param null $storeId
     * @return bool
     */
    protected function removeProductUrls($productId, $storeId = null)
    {
        if (!is_numeric($productId)) {
            return false;
        }
        $data = [
            UrlRewrite::ENTITY_ID => $productId,
            UrlRewrite::ENTITY_TYPE => \Magento\CatalogUrlRewrite\Model\ProductUrlRewriteGenerator::ENTITY_TYPE,
            UrlRewrite::IS_AUTOGENERATED => 1,
            UrlRewrite::REDIRECT_TYPE => 0,
            UrlRewrite::STORE_ID => $storeId
        ];

        try {
            $this->getUrlPersist()->deleteByData($data);
        } catch (\Exception $e) {
            $this->output->writeln($e->getMessage());
            return false;
        }
        return true;
    }

    /**
     *  Generate list of product urls
     *
     * @param $product
     * @return array
     */
    private function prepareUrls($product)
    {
        return $this->getProductUrlRewriteGenerator()->generate($product);
    }

    /**
     *  Get Product Url Generator
     *
     * @return \Magento\CatalogUrlRewrite\Model\ProductUrlRewriteGenerator
     */
    protected function getProductUrlRewriteGenerator()
    {
        return $this->getObjectManager()->create('\Magento\CatalogUrlRewrite\Model\ProductUrlRewriteGenerator');
    }



    /**
     * Prepare Collections to process
     *
     * @param $storeId
     * @param $productIds
     * @throws \Exception
     */
    protected function prepareCollections($storeId, $productIds)
    {
        if (\Magento\Store\Model\Store::DEFAULT_STORE_ID == $storeId) {
            $stores = $this->getStoreManager()->getStores();
        } else {
            $stores = [$this->getStoreManager()->getStore($storeId)];
        }
        if (empty($stores)) {
            throw new \Exception('Invalid store');
        }

        foreach ($stores as $store) {
            $this->_collection = null;
            $storeId = $store->getId();
            $this->getProductCollection();
            $this->addFilterProductIds($productIds);
            $this->addStoreFilter($storeId);

            $this->addCollections($this->_collection, $storeId);
        }
    }

    /**
     * Get product collection
     *
     * @return \Magento\Catalog\Model\ResourceModel\Product\Collection
     */
    protected function getProductCollection()
    {
        if (is_null($this->_collection)) {
            /** @var \Magento\Catalog\Model\ResourceModel\Product\Collection $collection */
            $this->_collection = $this->getObjectManager()->create('\Magento\Catalog\Model\ResourceModel\Product\CollectionFactory')->create();
        }
        return $this->_collection;
    }

    /**
     * Filter collection by product ID
     *
     * @param null $productIds
     */
    private function addFilterProductIds($productIds = null)
    {
        if (is_null($productIds) || is_null($this->_collection)) {
            return;
        }
        $this->_collection->addIdFilter(explode(',', $productIds));
    }

    /**
     * Filter Collection by Store
     *
     * @param null $storeId
     */
    private function addStoreFilter($storeId = null)
    {
        if (is_null($storeId) || is_null($this->_collection)) {
            return;
        }
        $this->_collection
            ->addStoreFilter($storeId)
            ->setStoreId($storeId);;
    }

    /**
     * Add collection to process
     *
     * @param \Magento\Catalog\Model\ResourceModel\Product\Collection $collection
     * @param $storeId
     */
    protected function addCollections(\Magento\Catalog\Model\ResourceModel\Product\Collection $collection, $storeId)
    {
        $this->_collections[$storeId] = $collection;
    }

    /**
     * Number of Items to process
     *
     * @return int
     */
    protected function getSizeToProcess()
    {
        $size = 0;
        foreach ($this->_collections as $collection) {
            $size += $collection->getSize();
        }
        return $size;
    }

    /**
     * Rebuild Urls
     */
    protected function rebuildUrls()
    {
        foreach ($this->_collections as $storeId => $collection) {
            $this->getIterator()->walk(
                $collection->getSelect(),
                [[$this, 'callbackGenerateProductUrl']],
                [
                    'product' => $this->getProductFactory(),
                    'storeId' => $storeId
                ]
            );
        }

    }

    /**
     * Create product factory
     *
     * @return \Magento\Catalog\Model\ProductFactory
     */
    protected function getProductFactory()
    {
        return $this->getObjectManager()->create('\Magento\Catalog\Model\ProductFactory')->create();
    }
}