Dynamic\Salsify\ORM\SalsifyFetchExtension

Complexity

Total Complexity

22

Size/Duplication

Total Lines	203
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getImporterKey()	0	3	1
A	canFetchSalsify()	0	14	5
A	onBeforeInit()	0	3	1
A	configContainsMapping()	0	11	3
A	getClassMapping()	0	10	3
A	fetchProduct()	0	27	2
A	mapData()	0	37	1
A	salsifyFetch()	0	31	6

<?php

namespace Dynamic\Salsify\ORM;

use Dynamic\Salsify\Model\Fetcher;
use Dynamic\Salsify\Model\Mapper;
use Dynamic\Salsify\Task\ImportTask;
use Dynamic\Salsify\Traits\InstanceCreator;
use GuzzleHttp\Client;
use SilverStripe\Admin\LeftAndMainExtension;

The type SilverStripe\Admin\LeftAndMainExtension was not found. Maybe you did not declare it correctly or list all dependencies?

use SilverStripe\Core\Config\Config;
use SilverStripe\Forms\Form;
use SilverStripe\ORM\DataObject;
use SilverStripe\Security\Security;

/**
 * Class LeftAndMainExtension
 * @package Dynamic\Salsify\ORM
 * @property-read \SilverStripe\Admin\LeftAndMain|\Dynamic\Salsify\ORM\SalsifyFetchExtension $owner
 */
class SalsifyFetchExtension extends LeftAndMainExtension
{
    use InstanceCreator;

    /**
     * @var bool
     */
    private $noChannel = true;

The private property $noChannel is not used, and could be removed.

    /**
     * @var array
     */
    private static $allowed_actions = [

The private property $allowed_actions is not used, and could be removed.

        'salsifyFetch',
    ];

    /**
     * @return string
     */
    protected function getImporterKey()
    {
        return 'single';
    }

    /**
     *
     */
    public function onBeforeInit()
    {
        $this->createServices();
    }

    /**
     * @return boolean
     * @throws \Exception
     */
    public function canFetchSalsify()
    {
        $className = $this->owner->currentPage()->getClassName();

        // Only allow when product has a salsify id and has a single mapping config
        if (
            $this->owner->currentPage()->SalsifyID &&
            $this->hasService(Mapper::class) &&
            $this->configContainsMapping($className) &&
            $this->getFetcher()->config()->get('organizationID')
        ) {
            return true;
        }
        return false;
    }

    /**
     * @param string $className
     *
     * @return boolean
     * @throws \Exception
     */
    private function configContainsMapping($className)
    {
        if (!$this->getMapper()->config()->get('mapping')) {
            return false;
        }

        if (!$this->getClassMapping($className)) {
            return false;
        }

        return true;
    }

    /**
     * @param string $className
     * @return bool|array
     * @throws \Exception
     */
    private function getClassMapping($className)
    {
        $mapping = $this->getMapper()->config()->get('mapping');
        if (array_key_exists($className, $mapping)) {
            return $mapping[$className];
        }
        if (array_key_exists('\\' . $className, $mapping)) {
            return $mapping['\\' . $className];
        }
        return false;
    }

    /**
     * @param array $data
     * @param Form $form
     * @return \SilverStripe\Control\HTTPResponse
     * @throws \Exception
     */
    public function salsifyFetch($data, $form)
    {
        $className = $this->owner->currentPage()->getClassName();

        $id = $data['ID'];
        /** @var DataObject|\Dynamic\Salsify\ORM\SalsifyIDExtension $record */
        $record = DataObject::get_by_id($className, $id);
        if ($record && !$record->canEdit()) {
            return Security::permissionFailure();
        }

        if (!$record || !$record->SalsifyID) {

$record is of type SilverStripe\ORM\DataObject, thus it always evaluated to true.

            $this->owner->httpError(404, "Bad salsify ID: $id");
        }

        ImportTask::config()->remove('output');
        $data = $this->fetchProduct($record->SalsifyID);
        if (array_key_exists('salsify:parent_id', $data)) {
            $parent = $this->fetchProduct($data['salsify:parent_id']);
            $data = array_merge($parent, $data);

It seems like $parent can also be of type null; however, parameter $arrays of array_merge() does only seem to accept array, maybe add an additional type check?

        }

        $this->changeToSalsifyUser();
        $this->mapData($record, $data);
        $this->changeToPreviousUser();

        $this->owner->getResponse()->addHeader(
            'X-Status',
            rawurlencode(_t(__CLASS__ . '.UPDATED', 'Updated.'))
        );
        return $this->owner->getResponseNegotiator()->respond($this->owner->getRequest());
    }

    /**
     * @param string $salsifyID
     * @return array|NULL
     * @throws \Exception
     */
    private function fetchProduct($salsifyID)
    {

        $apiKey = $this->getFetcher()->config()->get('apiKey');
        $timeout = $this->getFetcher()->config()->get('timeout');
        $orgID = $this->getFetcher()->config()->get('organizationID');

        $url = "v1/orgs/{$orgID}/products/{$salsifyID}";

        $client = new Client([
            'base_uri' => Fetcher::API_BASE_URL,
            'timeout' => $timeout,
            'http_errors' => false,
            'verify' => true,
            'headers' => [
                'Authorization' => 'Bearer ' . $apiKey,
                'Content-Type' => 'application/json',
            ],
        ]);

        $response = $client->get($url);

        if ($response->getStatusCode() == 404) {
            $this->owner->httpError(404, "Bad salsify ID: $salsifyID");
        }

        return json_decode($response->getBody(), true);
    }

    /**
     * @param DataObject $record
     * @param array $data
     * @throws \Exception
     */
    private function mapData($record, $data)
    {
        $forceUpdate = Config::inst()->get(
            $this->owner->currentPage()->getClassName(),
            'refetch_force_update'
        );

        $this->getFetcher()->config()->set('useLatest', true);
        $this->getFetcher()->startExportRun();
        $this->getFetcher()->waitForExportRunToComplete();
        $file = $this->getFetcher()->getExportUrl();

        $this->getMapper()->extend('onBeforeMap', $file, Mapper::$SINGLE);

        $this->getMapper()->mapToObject(
            $record->getClassName(),
            $this->getClassMapping($record->getClassName()),

It seems like $this->getClassMapping($record->getClassName()) can also be of type boolean; however, parameter $mappings of Dynamic\Salsify\Model\Mapper::mapToObject() does only seem to accept array, maybe add an additional type check?

            $data,
            $record,
            false,
            $forceUpdate
        );

        $forceUpdateRelations = Config::inst()->get(
            $this->owner->currentPage()->getClassName(),
            'refetch_force_update_relations'
        );
        $this->getMapper()->mapToObject(
            $record->getClassName(),
            $this->getClassMapping($record->getClassName()),
            $data,
            $record,
            true,
            $forceUpdateRelations
        );

        $this->getMapper()->extend('onAfterMap', $file, Mapper::$SINGLE);
    }
}