Flagbit\Bundle\ProductClonerBundle\Controller\ProductController

Complexity

Total Complexity

14

Size/Duplication

Total Lines	192
Duplicated Lines	0 %

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	removeIdentifierAttributeValue()	0	9	2
A	updateProduct()	0	17	2
A	getNormalizer()	0	3	1
A	__construct()	0	29	1
B	cloneAction()	0	55	7
A	getAttributeRepository()	0	3	1

<?php

namespace Flagbit\Bundle\ProductClonerBundle\Controller;

use Akeneo\Component\StorageUtils\Saver\SaverInterface;
use Akeneo\Component\StorageUtils\Updater\ObjectUpdaterInterface;
use Oro\Bundle\SecurityBundle\Annotation\AclAncestor;
use Pim\Bundle\UserBundle\Context\UserContext;
use Pim\Component\Catalog\Builder\ProductBuilderInterface;
use Pim\Component\Catalog\Comparator\Filter\FilterInterface;
use Pim\Component\Catalog\Localization\Localizer\AttributeConverterInterface;
use Pim\Component\Catalog\Model\ProductInterface;
use Pim\Component\Catalog\Repository\AttributeRepositoryInterface;
use Pim\Component\Catalog\Repository\ProductRepositoryInterface;
use Pim\Component\Enrich\Converter\ConverterInterface;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
use Symfony\Component\Validator\Validator\ValidatorInterface;

class ProductController extends AbstractController
{
    /**
     * @var ProductRepositoryInterface
     */
    private $productRepository;
    /**
     * @var ObjectUpdaterInterface
     */
    private $productUpdater;
    /**
     * @var SaverInterface
     */
    private $productSaver;
    /**
     * @var NormalizerInterface
     */
    private $normalizer;
    /**
     * @var ValidatorInterface
     */
    private $validator;
    /**
     * @var UserContext
     */
    private $userContext;
    /**
     * @var ProductBuilderInterface
     */
    private $productBuilder;
    /**
     * @var AttributeConverterInterface
     */
    private $localizedConverter;
    /**
     * @var FilterInterface
     */
    private $emptyValuesFilter;
    /**
     * @var ConverterInterface
     */
    private $productValueConverter;
    /**
     * @var NormalizerInterface
     */
    private $constraintViolationNormalizer;
    /**
     * @var ProductBuilderInterface
     */
    private $variantProductBuilder;
    /**
     * @var AttributeRepositoryInterface
     */
    private $attributeRepository;

    public function __construct(
        ProductRepositoryInterface $productRepository,
        AttributeRepositoryInterface $attributeRepository,
        ObjectUpdaterInterface $productUpdater,
        SaverInterface $productSaver,
        NormalizerInterface $normalizer,
        ValidatorInterface $validator,
        UserContext $userContext,
        ProductBuilderInterface $productBuilder,
        AttributeConverterInterface $localizedConverter,
        FilterInterface $emptyValuesFilter,
        ConverterInterface $productValueConverter,
        NormalizerInterface $constraintViolationNormalizer,
        ProductBuilderInterface $variantProductBuilder
    ) {

        $this->productRepository = $productRepository;
        $this->productUpdater = $productUpdater;
        $this->productSaver = $productSaver;
        $this->normalizer = $normalizer;
        $this->validator = $validator;
        $this->userContext = $userContext;
        $this->productBuilder = $productBuilder;
        $this->localizedConverter = $localizedConverter;
        $this->emptyValuesFilter = $emptyValuesFilter;
        $this->productValueConverter = $productValueConverter;
        $this->constraintViolationNormalizer = $constraintViolationNormalizer;
        $this->variantProductBuilder = $variantProductBuilder;
        $this->attributeRepository = $attributeRepository;
    }
    /**
     * @param Request $request
     *
     * @AclAncestor("pim_enrich_product_model_create")
     *
     * @return JsonResponse
     */
    public function cloneAction(Request $request) : JsonResponse
    {
        $data = json_decode($request->getContent(), true);

        // check 'code_to_clone' is provided otherwise HTTP bad request
        if (false === isset($data['code_to_clone'])) {
            return new JsonResponse('Field "code_to_clone" is missing.', Response::HTTP_BAD_REQUEST);
        }

        // check whether product to be cloned is found otherwise not found HTTP
        $product = $this->productRepository->findOneByIdentifier($data['code_to_clone']);
        if (null === $product) {
            return new JsonResponse(
                sprintf('Product model with code %s could not be found.', $data['code_to_clone']),
                Response::HTTP_NOT_FOUND
            );
        }
        unset($data['code_to_clone']);
        if (isset($data['parent'])) {
            // TODO: remove this as soon as support of 2.1 is dropped
            $cloneProduct = $this->variantProductBuilder->createProduct();
        } else {
            $cloneProduct = $this->productBuilder->createProduct(
                $data['code']
            );
            unset($data['code']);
        }

        // clone product using Akeneo normalizer
        $normalizedProduct = $this->normalizeProduct($product);

        $normalizedProduct = $this->removeIdentifierAttributeValue($normalizedProduct);

It seems like $normalizedProduct can also be of type boolean and double and integer and string; however, parameter $data of Flagbit\Bundle\ProductClonerBundle\Controller\ProductController::removeIdentifierAttributeValue() does only seem to accept array, maybe add an additional type check?

        $this->productUpdater->update($cloneProduct, $normalizedProduct);
        if (!empty($data['values'])) {
            $this->updateProduct($cloneProduct, $data);
        }
        // validate product model clone and return violations if found
        $violations = $this->validator->validate($cloneProduct);
        if (count($violations) > 0) {
            $normalizedViolations = [];
            foreach ($violations as $violation) {
                $violation = $this->constraintViolationNormalizer->normalize(
                    $violation,
                    'internal_api',
                    ['product' => $cloneProduct]
                );
                $normalizedViolations[] = $violation;
            }

            return new JsonResponse(['values' => $normalizedViolations], Response::HTTP_BAD_REQUEST);
        }

        $this->productSaver->save($cloneProduct);

        return new JsonResponse();
    }

    private function removeIdentifierAttributeValue(array $data): array
    {
        unset($data['identifier']);
        $identifierAttributeCode = $this->attributeRepository->getIdentifier()->getCode();

        if (isset($data['values'][$identifierAttributeCode])) {
            unset($data['values'][$identifierAttributeCode]);
        }
        return $data;
    }
    /**
     * Updates product with the provided request data
     *
     * @param ProductInterface $product
     * @param array            $data
     */
    private function updateProduct(ProductInterface $product, array $data)
    {
        $values = $this->productValueConverter->convert($data['values']);

        $values = $this->localizedConverter->convertToDefaultFormats($values, [
            'locale' => $this->userContext->getUiLocale()->getCode()
        ]);

        $dataFiltered = $this->emptyValuesFilter->filter($product, ['values' => $values]);

        if (!empty($dataFiltered)) {
            $data = array_replace($data, $dataFiltered);
        } else {
            $data['values'] = [];
        }

        $this->productUpdater->update($product, $data);
    }

    protected function getNormalizer(): NormalizerInterface
    {
        return $this->normalizer;
    }

    protected function getAttributeRepository(): AttributeRepositoryInterface
    {
        return $this->attributeRepository;
    }
}