Shopware_Controllers_Backend_Import

Complexity

Total Complexity

59

Size/Duplication

Total Lines	577
Duplicated Lines	3.47 %

Coupling/Cohesion

Components	3
Dependencies	8

Importance

Changes

0

25 Methods

Rating	Name	Duplication	Size	Complexity
A	getHelper()	0	4	1
A	getConnectFactory()	0	8	2
B	getImportedProductCategoriesTreeAction()	0	58	7
A	loadArticlesByRemoteCategoryAction()	0	46	2
A	loadBothArticleTypesAction()	0	22	2
B	assignArticlesToCategoryAction()	0	53	5
A	unassignRemoteArticlesFromLocalCategoryAction()	0	20	2
B	assignRemoteToLocalCategoryAction()	0	55	8
A	getArticleCountForRemoteCategoryAction()	0	23	2
A	assignArticlesToRemoteCategoryAction()	0	26	2
A	unassignRemoteToLocalCategoryAction()	0	30	3
A	activateArticlesAction()	20	20	2
A	deactivateCategoryAction()	0	33	4
A	getSuppliersAction()	0	19	2
A	recreateRemoteCategoriesAction()	0	8	1
A	getCategoryExtractor()	0	15	2
A	getPdoGateway()	0	4	1
A	getProductToRemoteCategoryRepository()	0	10	2
A	getImportService()	0	4	1
A	getAutoCategoryReverter()	0	4	1
A	getCategoryRepository()	0	8	2
A	getLogger()	0	8	2
A	connectCategoriesNeedRecoveryAction()	0	9	1
A	connectCategoriesNeedAdditionalShopIdAction()	0	9	1
A	productCountForCategoryRecoveryAction()	0	9	1

<?php
/**
 * (c) shopware AG <info@shopware.com>
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
use ShopwarePlugins\Connect\Components\ConnectFactory;

/**
 * Class Shopware_Controllers_Backend_Import
 */
class Shopware_Controllers_Backend_Import extends Shopware_Controllers_Backend_ExtJs
{
    private $categoryExtractor;

    /**
     * @var \Shopware\CustomModels\Connect\ProductToRemoteCategory
     */
    private $productToRemoteCategoryRepository;

    private $remoteCategoryRepository;

    private $categoryRepository;

    private $logger;

    private $factory;

    /**
     * @return \ShopwarePlugins\Connect\Components\Helper
     */
    public function getHelper()
    {
        return $this->getConnectFactory()->getHelper();
    }

    /**
     * @return ConnectFactory
     */
    public function getConnectFactory()
    {
        if ($this->factory === null) {
            $this->factory = new ConnectFactory();
        }

        return $this->factory;
    }

    public function getImportedProductCategoriesTreeAction()
    {
        $parent = $this->request->getParam('categoryId', 'root');
        $hideMapped = (bool) $this->request->getParam('hideMappedProducts', false);

        $query = $this->request->getParam('remoteCategoriesQuery', '');
        $node = $this->request->getParam('id');

        if (trim($query) !== '') {
            try {
                $categories = $this->getCategoryExtractor()->getNodesByQuery($hideMapped, $query, $parent, $node);
                $this->View()->assign([
                    'success' => true,
                    'data' => $categories,
                ]);
            } catch (\InvalidArgumentException $e) {
                $this->View()->assign([
                    'success' => false,
                    'message' => $e->getMessage(),
                ]);
            }

            return;
        }

        switch ($parent) {
            case 'root':
                $categories = $this->getCategoryExtractor()->getMainNodes($hideMapped);
                break;
            case is_numeric($parent):
                $categories = $this->getCategoryExtractor()->getStreamsByShopId($parent);
                break;
            case strpos($parent, '_stream_') > 0:
                list($shopId, $stream) = explode('_stream_', $parent);
                $categories = $this->getCategoryExtractor()->getRemoteCategoriesTreeByStream($stream, $shopId, $hideMapped);
                break;
            default:
                // given id must have following structure:
                // shopId5~stream~AwesomeProducts~/english/boots/nike
                // shopId is required parameter to fetch all child categories of this parent
                try {
                    list($shopId, $stream) = $this->getCategoryExtractor()->extractNode($node);
                } catch (\InvalidArgumentException $e) {
                    $this->View()->assign([
                        'success' => false,
                        'message' => $e->getMessage(),
                    ]);

                    return;
                }
                $categories = $this->getCategoryExtractor()->getRemoteCategoriesTree($parent, false, $hideMapped, $shopId, $stream);
        }

        $this->View()->assign([
            'success' => true,
            'data' => $categories,
        ]);
    }

    public function loadArticlesByRemoteCategoryAction()
    {
        $category = $this->request->getParam('category', null);
        $shopId = $this->request->getParam('shopId', 0);
        $limit = (int) $this->request->getParam('limit', 10);
        $offset = (int) $this->request->getParam('start', 0);
        $hideMapped = (bool) $this->request->getParam('hideMappedProducts', false);
        $searchQuery = $this->request->getParam('remoteArticlesQuery', '');

        $stream = $this->request->getParam('stream', null);

        if (strpos($category, '_stream_') > 0) {
            $snippets = $this->get('snippets')->getNamespace('backend/connect/view/main');

            $this->View()->assign([
                'success' => false,
                'message' => $snippets->get(
                    'import/message/dont_select_streams',
                    'Please select a Category to display its products',
                    true
                ),
            ]);

            return;
        }

        $query = $this->getProductToRemoteCategoryRepository()->findArticlesByRemoteCategory(
            $category,
            $shopId,
            $stream,
            $limit,
            $offset,
            $hideMapped,
            $searchQuery
        );

        $query->setHydrationMode($query::HYDRATE_OBJECT);

        $paginator = new \Doctrine\ORM\Tools\Pagination\Paginator($query);
        $totalCount = $paginator->count();
        $this->View()->assign([
            'success' => true,
            'data' => $query->getArrayResult(),
            'total' => $totalCount,
        ]);
    }

    public function loadBothArticleTypesAction()
    {
        $categoryId = (int) $this->request->getParam('categoryId', 0);
        $limit = (int) $this->request->getParam('limit', 10);
        $offset = (int) $this->request->getParam('start', 0);
        $showOnlyConnectArticles = $this->request->getParam('showOnlyConnectArticles', null);
        $query = $this->request->getParam('localArticlesQuery', '');

        $result = $this->getImportService()->findBothArticlesType(
            $categoryId,
            $query,
            $showOnlyConnectArticles ? true : false,
            $limit,
            $offset
        );

        $this->View()->assign([
            'success' => true,
            'data' => $result['data'],
            'total' => $result['total'],
        ]);
    }

    public function assignArticlesToCategoryAction()
    {
        $categoryId = (int) $this->request->getParam('categoryId', 0);
        $articleIds = $this->request->getParam('articleIds', []);

        $snippets = Shopware()->Snippets()->getNamespace('backend/connect/view/main');

        if ($categoryId == 0 || empty($articleIds)) {
            $this->View()->assign([
                'success' => false,
                'message' => $snippets->get(
                    'import/message/category_has_children',
                    'Invalid category or articles',
                    true
                ),
            ]);

            return;
        }

        if ($this->getImportService()->hasCategoryChildren($categoryId)) {
            $this->View()->assign([
                'success' => false,
                'message' => $snippets->get(
                    'import/message/category_has_children',
                    'Category has subcategories, please make sure you have selected single one',
                    true
                ),
            ]);

            return;
        }

        try {
            $this->getImportService()->assignCategoryToArticles($categoryId, $articleIds);
        } catch (\RuntimeException $e) {
            $this->getLogger()->write(true, $e->getMessage(), $e);
            $this->View()->assign([
                'success' => false,
                'message' => $snippets->get(
                    'import/message/failed_product_to_category_assignment',
                    'Category could not be assigned to products!',
                    true
                ),
            ]);

            return;
        }

        $this->View()->assign([
            'success' => true
        ]);
    }

    /**
     * Unassign all categories from articles
     */
    public function unassignRemoteArticlesFromLocalCategoryAction()
    {
        $articleIds = $this->request->getParam('articleIds', []);
        $categoryId = (int) $this->request->getParam('categoryId');
        try {
            $this->getImportService()->unAssignArticleCategories($articleIds, $categoryId);
        } catch (\Exception $e) {
            $this->getLogger()->write(true, $e->getMessage(), $e);
            $this->View()->assign([
                'success' => false,
                'error' => 'Categories could not be unassigned from products!',
            ]);

            return;
        }

        $this->View()->assign([
            'success' => true
        ]);
    }

    public function assignRemoteToLocalCategoryAction()
    {
        $localCategoryId = (int) $this->request->getParam('localCategoryId', 0);
        $remoteCategoryKey = $this->request->getParam('remoteCategoryKey', null);
        $remoteCategoryLabel = $this->request->getParam('remoteCategoryLabel', null);
        $node = $this->request->getParam('node', null);

        if ($localCategoryId == 0 || !$remoteCategoryKey || !$remoteCategoryLabel) {
            $this->View()->assign([
                'success' => false,
                'error' => 'Invalid local or remote category',
            ]);

            return;
        }

        try {
            list($shopId, $stream) = $this->getCategoryExtractor()->extractNode($node);
        } catch (\InvalidArgumentException $e) {
            $this->View()->assign([
                'success' => false,
                'message' => $e->getMessage(),
            ]);

            return;
        }

        if (!$shopId || !$stream) {
            $this->View()->assign([
                'success' => false,
                'message' => 'Node must contain shopId and stream',
            ]);

            return;
        }

        try {
            $categories = $this->getImportService()->importRemoteCategoryCreateLocalCategories($localCategoryId, $remoteCategoryKey, $remoteCategoryLabel, $shopId, $stream);
        } catch (\RuntimeException $e) {
            $this->getLogger()->write(true, $e->getMessage(), $e);
            $this->View()->assign([
                'success' => false,
                'error' => 'Remote category could not be mapped to local category!',
            ]);

            return;
        }

        $this->View()->assign([
            'success' => true,
            'categories' => $categories,
            'shopId' => $shopId,
            'stream' => $stream
        ]);
    }

    public function getArticleCountForRemoteCategoryAction()
    {
        $remoteCategoryKey = $this->request->getParam('remoteCategoryKey', '');
        $shopId = (int) $this->request->getParam('shopId', 0);
        $stream = $this->request->getParam('stream', '');

        try {
            $articleCount = $this->getImportService()->importRemoteCategoryGetArticleCountForCategory($shopId, $remoteCategoryKey, $stream);
        } catch (\RuntimeException $e) {
            $this->getLogger()->write(true, $e->getMessage(), $e);
            $this->View()->assign([
                'success' => false,
                'error' => 'Articles could not be counted!',
            ]);

            return;
        }

        $this->View()->assign([
            'success' => true,
            'count' => (int) $articleCount
        ]);
    }

    public function assignArticlesToRemoteCategoryAction()
    {
        $remoteCategoryKey = $this->request->getParam('remoteCategoryKey', '');
        $localCategoryId = (int) $this->request->getParam('localCategoryId', 0);
        $localParentId = (int) $this->request->getParam('localParentId', 0);
        $offset = (int) $this->request->getParam('offset', 0);
        $limit = (int) $this->request->getParam('limit', 0);
        $shopId = (int) $this->request->getParam('shopId', 0);
        $stream = $this->request->getParam('stream', '');

        try {
            $this->getImportService()->importRemoteCategoryAssignArticles($shopId, $remoteCategoryKey, $stream, $localCategoryId, $localParentId, $offset, $limit);
        } catch (\RuntimeException $e) {
            $this->getLogger()->write(true, $e->getMessage(), $e);
            $this->View()->assign([
                'success' => false,
                'error' => 'Articles could not be assigned to local Categorys!',
            ]);

            return;
        }

        $this->View()->assign([
            'success' => true,
        ]);
    }

    /**
     * Unassign all remote articles from local category
     */
    public function unassignRemoteToLocalCategoryAction()
    {
        $localCategoryId = (int) $this->request->getParam('localCategoryId', 0);

        if ($localCategoryId == 0) {
            $this->View()->assign([
                'success' => false,
                'error' => 'Invalid local or remote category',
            ]);

            return;
        }

        try {
            $articleIds = $this->getImportService()->findRemoteArticleIdsByCategoryId($localCategoryId);
            $this->getImportService()->unAssignArticleCategories($articleIds);
        } catch (\Exception $e) {
            $this->getLogger()->write(true, $e->getMessage(), $e);
            $this->View()->assign([
                'success' => false,
                'error' => 'Products from remote category could not be unassigned!',
            ]);

            return;
        }

        $this->View()->assign([
            'success' => true
        ]);
    }

    public function activateArticlesAction()

This method seems to be duplicated in your project.

    {
        $articleIds = $this->request->getParam('ids', 0);

        try {
            $this->getImportService()->activateArticles($articleIds);
        } catch (\Exception $e) {
            $this->getLogger()->write(true, $e->getMessage(), $e);
            $this->View()->assign([
                'success' => false,
                'error' => 'There is a problem with products activation!',
            ]);

            return;
        }

        $this->View()->assign([
            'success' => true,
        ]);
    }

    /**
     * Deactivates connect categories
     */
    public function deactivateCategoryAction()
    {
        $categoryId = $this->request->getParam('categoryId', 0);

        if (!$categoryId) {
            return $this->View()->assign([
                'success' => false,
                'error' => 'Please select a category for deactivation',
            ]);
        }

        /** @var \Shopware\Models\Category\Category $category */
        $category = $this->getCategoryRepository()->findOneBy(['id' => $categoryId]);

        if (!$category) {
            $this->View()->assign([
                'success' => false,
                'error' => 'Please select a valid category for deactivation',
            ]);
        }

        $categoryIds = $this->getCategoryExtractor()->getCategoryIdsCollection($category);

        $changedCount = 0;
        if (count($categoryIds) > 0) {
            $changedCount = $this->getImportService()->deactivateLocalCategoriesByIds($categoryIds);
        }

        $this->View()->assign([
            'success' => true,
            'deactivatedCategoriesCount' => $changedCount,
        ]);
    }

    /**
     * @return Enlight_View|Enlight_View_Default
     */
    public function getSuppliersAction()
    {
        $suppliers = [];
        $pdoGateway = $this->getPdoGateway();

        foreach ($pdoGateway->getConnectedShopIds() as $shopId) {
            $configuration = $pdoGateway->getShopConfiguration($shopId);
            $suppliers = [
                'id' => $shopId,
                'name' => $configuration->displayName,
                'logoUrl' => $configuration->logoUrl,
            ];
        }

        return $this->View()->assign([
            'success' => true,
            'data' => $suppliers,
        ]);
    }

    public function recreateRemoteCategoriesAction()
    {
        $this->getAutoCategoryReverter()->recreateRemoteCategories();

        return $this->View()->assign([
            'success' => true,
        ]);
    }

    private function getCategoryExtractor()
    {
        if (!$this->categoryExtractor) {
            $modelManager = Shopware()->Models();
            $this->categoryExtractor = new \ShopwarePlugins\Connect\Components\CategoryExtractor(
                $modelManager->getRepository('Shopware\CustomModels\Connect\Attribute'),
                $this->container->get('swagconnect.auto_category_resolver'),
                $this->getPdoGateway(),
                new \ShopwarePlugins\Connect\Components\RandomStringGenerator(),
                Shopware()->Db()
            );
        }

        return $this->categoryExtractor;
    }

    /**
     * @return \Shopware\Connect\Gateway\PDO
     */
    private function getPdoGateway()
    {
        return new \Shopware\Connect\Gateway\PDO(Shopware()->Db()->getConnection());
    }

    /**
     * @return \Shopware\CustomModels\Connect\ProductToRemoteCategoryRepository
     */
    private function getProductToRemoteCategoryRepository()
    {
        if (!$this->productToRemoteCategoryRepository) {
            $this->productToRemoteCategoryRepository = Shopware()->Models()->getRepository(
                'Shopware\CustomModels\Connect\ProductToRemoteCategory'
            );
        }

        return $this->productToRemoteCategoryRepository;
    }

    /**
     * @return \ShopwarePlugins\Connect\Components\ImportService
     */
    private function getImportService()
    {
        return $this->container->get('swagconnect.import_service');
    }

    private function getAutoCategoryReverter()
    {
        return $this->container->get('swagconnect.auto_category_reverter');
    }

    /**
     * @return \Shopware\Models\Category\Repository
     */
    private function getCategoryRepository()
    {
        if (!$this->categoryRepository) {
            $this->categoryRepository = $this->getModelManager()->getRepository('Shopware\Models\Category\Category');
        }

        return $this->categoryRepository;
    }

    private function getLogger()
    {
        if (!$this->logger) {
            $this->logger = new \ShopwarePlugins\Connect\Components\Logger(Shopware()->Db());
        }

        return $this->logger;
    }

    public function connectCategoriesNeedRecoveryAction()
    {
        $this->View()->assign([
            'success' => true,
            'data' => [
                'recreateConnectCategories' => $this->getHelper()->checkIfConnectCategoriesHaveToBeRecreated(),
            ]
        ]);
    }

    public function connectCategoriesNeedAdditionalShopIdAction()
    {
        $this->View()->assign([
            'success' => true,
            'data' => [
                'addShopIdToConnectCategories' => $this->getHelper()->checkIfShopIdHasToBeAddedToConnectCategories(),
            ]
        ]);
    }

    public function productCountForCategoryRecoveryAction()
    {
        $this->View()->assign([
            'success' => true,
            'data' => [
                'totalCount' => $this->getHelper()->getProductCountForCategoryRecovery(),
            ]
        ]);
    }
}