Mapper::__construct() - Code Metrics - Inspection of "File mapping" - dynamic/silverstripe-salsify - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#11)

by Matthew
created 2019-06-12 15:34 UTC
Mapper::__construct() A

↳ Parent: Mapper
Complexity

Conditions	1
Paths	1
Size

Total Lines	5
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	3
nc	1
nop	1
dl	0
loc	5
rs	10
c	0
b	0
f	0
<?php

namespace Dynamic\Salsify\Model;

use Dynamic\Salsify\Task\ImportTask;
use JsonMachine\JsonMachine;
use SilverStripe\Assets\File;
use SilverStripe\Assets\Image;
use SilverStripe\Core\Config\Configurable;
use SilverStripe\Core\Extensible;
use SilverStripe\Core\Injector\Injectable;
use SilverStripe\ORM\DataObject;

/**
 * Class Mapper
 * @package Dynamic\Salsify\Model
 */
class Mapper
{
    use Configurable;
    use Extensible;
    use Injectable;

    /**
     * @var array
     */
    private static $field_types = [
        'RAW' => '0',
        'FILE' => '1',
        'IMAGE' => '2',
    ];

    /**
     * @var
     */
    private $file;

    /**
     * @var JsonMachine
     */
    private $productStream;

    /**
     * @var JsonMachine
     */
    private $assetStream;

    /**
     * @var array
     */
    private $currentUniqueFields;

    /**
     * @var int
     */
    private $importCount = 0;

    /**
     * Mapper constructor.
     * @param $file
     */
    public function __construct($file)
    {
        $this->file = $file;
        $this->productStream = JsonMachine::fromFile($file, '/4/products');
        $this->resetAssetStream();
    }

    /**
     * Maps the data
     */
    public function map()
    {
        foreach ($this->productStream as $name => $data) {
            foreach ($this->config()->get('mapping') as $class => $mappings) {
                $this->mapToObject($class, $mappings, $data);
                $this->currentUniqueFields = [];
            }
        }
        ImportTask::echo("Imported and updated $this->importCount products.");
    }

    /**
     * @param string $class
     * @param array $mappings
     * @param array $data
     */
    private function mapToObject($class, $mappings, $data)
    {
        $object = $this->findObjectByUnique($class, $mappings, $data);
        if (!$object) {

            $object = $class::create();
        }

        $fieldTypes = $this->config()->get('field_types');

        $firstUniqueKey = array_keys($this->uniqueFields($class, $mappings))[0];
        $firstUniqueValue = $data[$mappings[$firstUniqueKey]['salsifyField']];
        ImportTask::echo("Updating $firstUniqueKey $firstUniqueValue");

        foreach ($mappings as $dbField => $salsifyField) {
            $type = $this->config()->get('field_types')['RAW'];
            if (is_array($salsifyField)) {
                if (!array_key_exists('salsifyField', $salsifyField)) {
                    continue;
                }

                if (array_key_exists('type', $salsifyField)) {
                    if (array_key_exists($salsifyField['type'], $fieldTypes)) {
                        $type = $fieldTypes[$salsifyField['type']];
                    }
                }

                $salsifyField = $salsifyField['salsifyField'];
            }

            if (!array_key_exists($salsifyField, $data)) {
                ImportTask::echo("Skipping mapping for field $salsifyField for $firstUniqueKey $firstUniqueValue");
                continue;
            }

            $object->$dbField = $this->handleType($type, $data[$salsifyField], $dbField);
        }

        if ($object->isChanged()) {
            $object->write();
            $this->importCount++;
        } else {
            ImportTask::echo("$firstUniqueKey $firstUniqueValue was not changed.");
        }
    }

    /**
     * @param string $class
     * @param array $mappings
     * @param array $data
     *
     * @return \SilverStripe\ORM\DataObject
     */
    private function findObjectByUnique($class, $mappings, $data)
    {
        $uniqueFields = $this->uniqueFields($class, $mappings);
        $filter = [];
        foreach ($uniqueFields as $dbField => $salsifyField) {
            $filter[$dbField] = $data[$salsifyField];
        }

        return DataObject::get($class)->filter($filter)->first();
    }

    /**
     * @param string $class
     * @param array $mappings
     * @return array
     */
    private function uniqueFields($class, $mappings)
    private function uniqueFields(/** @scrutinizer ignore-unused */ $class, $mappings)
    {
        if (!empty($this->currentUniqueFields)) {
            return $this->currentUniqueFields;
        }

        $uniqueFields = [];
        foreach ($mappings as $dbField => $salsifyField) {
            if (!is_array($salsifyField)) {
                continue;
            }

            if (!array_key_exists('unique', $salsifyField) ||
                !array_key_exists('salsifyField', $salsifyField)) {
                continue;
            }

            if (!$salsifyField['unique'] == true) {

                continue;
            }

            $uniqueFields[$dbField] = $salsifyField['salsifyField'];
        }

        $this->currentUniqueFields = $uniqueFields;
        return $uniqueFields;
    }

    /**
     * @param int $type
     * @param string|int $value
     * @param string $dbField
     * @return mixed
     */
    private function handleType($type, $value, $dbField)
    {
        $fieldTypes = $this->config()->get('field_types');
        switch ($type) {
            case $fieldTypes['RAW']:
                return $value;

            case $fieldTypes['FILE']:
                if ($asset = $this->createFile($this->getAssetBySalsifyID($value))) {

                    return preg_match('/ID$/', $dbField) ? $asset->ID : $asset;
                }

            case $fieldTypes['IMAGE']:
                $asset = $this->getAssetBySalsifyID($value);

                $file = $this->findOrCreateFile($asset['salsify:id'], Image::class);
                if ($file->SalsifyUpdatedAt && $file->SalsifyUpdatedAt == $asset['salsify:updated_at']) {
                    return preg_match('/ID$/', $dbField) ? $file->ID : $file;

                }

                $url = $asset['salsify:url'];
                $name = $asset['salsify:name'];
                $supportedImageExtensions = Image::get_category_extensions(
                    Image::singleton()->File->getAllowedCategories()
                );

                if (!in_array(pathinfo($asset['salsify:url'])['extension'], $supportedImageExtensions)) {
                    $url = str_replace(
                        '.' . pathinfo($asset['salsify:url'])['extension'],
                        '.png',
                        $asset['salsify:url']
                    );
                }

                if (!in_array(pathinfo($asset['salsify:name'])['extension'], $supportedImageExtensions)) {
                    $name = str_replace(
                        '.' . pathinfo($asset['salsify:name'])['extension'],
                        '.png',
                        $asset['salsify:name']
                    );
                }

                $file->SalsifyUpdatedAt = $asset['salsify:updated_at'];
                $file->setFromStream(fopen($url, 'r'), $name);
                       setFromStream(fopen($url, 'r'), $name);
                $file->write();
                       write();
                return preg_match('/ID$/', $dbField) ? $file->ID : $file;
        }
        return '';
    }

    /**
     * @param $id
     * @return array|bool
     */
    private function getAssetBySalsifyID($id)
    {
        if (is_array($id)) {
            $id = $id[count($id) - 1];
        }

        $asset = false;
        foreach ($this->assetStream as $name => $data) {
            if ($data['salsify:id'] == $id) {
                $asset = $data;
            }
        }
        $this->resetAssetStream();
        return $asset;
    }

    /**
     * @param array|bool $assetData
     * @param string $class
     * @return File|bool
     */
    private function createFile($assetData)
    {
        if (!$assetData) {
            return false;
        }

        $file = $this->findOrCreateFile($assetData['salsify:id']);
        if ($file->SalsifyUpdatedAt && $file->SalsifyUpdatedAt == $assetData['salsify:updated_at']) {
            return $file;

        }

        $file->SalsifyUpdatedAt = $assetData['salsify:updated_at'];
        $file->setFromStream(fopen($assetData['salsify:url'], 'r'), $assetData['salsify:name']);

        $file->write();
        return $file;

    }

    /**
     * @param string $id
     * @param string $class
     * @return File|\Dyanmic\Salsify\ORM\FileExtension
     */
    private function findOrCreateFile($id, $class = File::class)
    {
        /** @var File|\Dyanmic\Salsify\ORM\FileExtension $file */
        if ($file = $class::get()->find('SalisfyID', $id)) {
            return $file;
        }

        $file = $class::create();
        $file->SalisfyID = $id;
        return $file;
    }

    /**
     *
     */
    private function resetAssetStream()
    {
        $this->assetStream = JsonMachine::fromFile($this->file, '/3/digital_assets');
    }
}

dynamic / silverstripe-salsify

Pull Request — master (#11)

Mapper::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
