ImageHandler::handleManyImagesType() - Code Metrics - dynamic/silverstripe-salsify - Measure and Improve Code Quality continuously with Scrutinizer

ImageHandler::handleManyImagesType() A
last analyzed 2021-10-21 15:43 UTC

↳ Parent: ImageHandler

Complexity

Conditions	3
Paths	4

Size

Total Lines	16
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	9
c	1
b	0
f	0
dl	0
loc	16
rs	9.9666
cc	3
nc	4
nop	5

<?php

namespace Dynamic\Salsify\TypeHandler\Asset;

use Dynamic\Salsify\Task\ImportTask;
use SilverStripe\Assets\Image;
use SilverStripe\ORM\DataObject;

/**
 * Class ImageHandler
 * @package Dynamic\Salsify\TypeHandler
 *
 * @property-read \Dynamic\Salsify\Model\Mapper|ImageHandler $owner
 */
class ImageHandler extends AssetHandler
{

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

        'Image' => [
            'requiresWrite' => true,
            'requiresSalsifyObjects' => false,
            'allowsModification' => true,
        ],
        'ManyImages' => [
            'requiresWrite' => true,
            'requiresSalsifyObjects' => false,
            'allowsModification' => true,
        ],
    ];

    /**
     * @var string
     */
    private static $defaultImageType = 'png';


    /**
     * @param string $url
     * @param array|string $transformations
     */
    public function getImageTransformation($url, $transformations)
    public function getImageTransformation(/** @scrutinizer ignore-unused */ $url, $transformations)
    {
        if (!is_array($transformations)) {
            $transformations = [$transformations];
        }

        return implode(',', $transformations);
    }

    /**
     * @param string $url
     * @param string $transform
     */
    public function getImageTransformationURL($url, $transform)
    {
        $filePath = preg_split('|^(.*[\\\/])|', $url, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY)[0];
        $fileName = basename($url);

        return "{$filePath}{$transform}/{$fileName}";
    }

    /**
     * @param string|DataObject $class
     * @param $data
     * @param $dataField
     * @param $config
     * @param $dbField
     * @return string|int
     *
     * @throws \Exception
     */
    public function handleImageType($class, $data, $dataField, $config, $dbField)
    public function handleImageType(/** @scrutinizer ignore-unused */ $class, $data, $dataField, $config, $dbField)
    {
        $assetData = $this->getAssetBySalsifyID($data[$dataField]);
        if (!$assetData) {
            return '';
        }

        $url = $this->fixExtension($assetData['salsify:url']);
        $name = $this->fixExtension($assetData['salsify:name']);
        $transformation = '';

        if (array_key_exists('transform', $config)) {
            $transformation = $this->getImageTransformation($url, $config['transform']);
            $url = $this->getImageTransformationURL($url, $transformation);
        }

        $asset = $this->updateFile(
            $assetData['salsify:id'],
            $assetData['salsify:updated_at'],
            $url,
            $name,
            $config['type'],
            Image::class,
            $transformation
        );

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

    protected function fixExtension($string)
    {
        $supportedImageExtensions = Image::get_category_extensions(
            Image::singleton()->File->getAllowedCategories()
        );

        $pathinfo = pathinfo($string);
        $defualtExtension = $this->owner->config()->get('defaultImageType');
        $defualtExtension = $this->owner->/** @scrutinizer ignore-call */ config()->get('defaultImageType');
        if (!array_key_exists('extension', $pathinfo)) {
        if (!array_key_exists('extension', /** @scrutinizer ignore-type */ $pathinfo)) {
            return "{$string}.{$defualtExtension}";
        }

        $extension = pathinfo($string)['extension'];

        if (!in_array($extension, $supportedImageExtensions)) {
            return str_replace(
                ".{$extension}",
                ".{$defualtExtension}",
                $string
            );
        }

        return $string;
    }

    /**
     * @param string|DataObject $class
     * @param $data
     * @param $dataField
     * @param $config
     * @param $dbField
     * @return array
     *
     * @throws \Exception
     */
    public function handleManyImagesType($class, $data, $dataField, $config, $dbField)
    {
        $files = [];
        $fieldData = $data[$dataField];
        // convert to array to prevent problems
        if (!is_array($fieldData)) {
            $fieldData = [$fieldData];
        }

        foreach ($this->owner->yieldSingle($fieldData) as $fileID) {
        foreach ($this->owner->/** @scrutinizer ignore-call */ yieldSingle($fieldData) as $fileID) {
            $entryData = array_merge($data, [
                $dataField => $fileID
            ]);
            $files[] = $this->owner->handleImageType($class, $entryData, $dataField, $config, $dbField, $class);
            $files[] = $this->owner->handleImageType($class, $entryData, $dataField, $config, $dbField, $class);
        }
        return $files;
    }
}


dynamic / silverstripe-salsify

ImageHandler::handleManyImagesType() A last analyzed 2021-10-21 15:43 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ImageHandler::handleManyImagesType() A
last analyzed 2021-10-21 15:43 UTC