LocatorControllerExtension::getClusterImageFromPath() - Code Metrics - Inspection of "Fixed error when no cluster images are set (#55)" - dynamic/silverstripe-locator-frontend-react - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 6ccdbd...5b2198 )

by Matthew
created 2020-01-30 16:10 UTC
getClusterImageFromPath() A

↳ Parent: LocatorControllerExtension
Complexity

Conditions	4
Paths	4
Size

Total Lines	17
Code Lines	8
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	20
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	4
eloc	8
c	1
b	0
f	0
nc	4
nop	1
dl	0
loc	17
ccs	0
cts	9
cp	0
crap	20
rs	10
<?php

namespace Dynamic\Locator\React\Extensions;

use Dynamic\SilverStripeGeocoder\AddressDataExtension;
use Dynamic\SilverStripeGeocoder\GoogleGeocoder;
use SilverStripe\Admin\LeftAndMain;
use SilverStripe\Control\Director;
use SilverStripe\Control\HTTPResponse;
use SilverStripe\Core\Config\Config;
use SilverStripe\Core\Convert;
use SilverStripe\Core\Extension;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\Core\Manifest\ModuleResourceLoader;
use SilverStripe\Forms\Schema\FormSchema;
use SilverStripe\Security\SecurityToken;
use SilverStripe\View\Requirements;
use SilverStripe\View\SSViewer;
use SilverStripe\View\ThemeResourceLoader;

/**
 * Class LocatorControllerExtension
 * @package Dynamic\Locator\React\Extensions
 *
 * @property \Dynamic\Locator\LocatorController|LocatorControllerExtension|LocatorExtension $owner
 */
class LocatorControllerExtension extends Extension
{

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

        'schema',
    ];

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

        'FormSchema' => '%$' . FormSchema::class,
    ];

    /**
     * Current form schema helper
     *
     * @var FormSchema
     */
    protected $schema = null;

    /**
     * Get form schema helper
     *
     * @return FormSchema
     */
    public function getFormSchema()
    {
        return $this->schema;
    }

    /**
     * Set form schema helper for this controller
     *
     * @param FormSchema $schema
     * @return $this
     */
    public function setFormSchema(FormSchema $schema)
    {
        $this->schema = $schema;
        return $this;
    }

    /**
     *
     */
    public function onBeforeInit()
    {
        // stops script from loading
        Requirements::block('jquery-locator');

        // require i18n translation stuff
        Requirements::javascript('silverstripe/admin: client/dist/js/i18n.js');
        Requirements::add_i18n_javascript('dynamic/silverstripe-locator-react: client/lang');
        /** @scrutinizer ignore-deprecated */ Requirements::add_i18n_javascript('dynamic/silverstripe-locator-react: client/lang');

        // because we need another library when using autocomplete
        if ($this->owner->Autocomplete) {

            // google maps api key
            $key = Config::inst()->get(GoogleGeocoder::class, 'map_api_key');
            Requirements::block("https://maps.google.com/maps/api/js?key={$key}");
            Requirements::javascript("https://maps.google.com/maps/api/js?key={$key}&libraries=places");
        }

        Requirements::customScript("
            window.ss = window.ss || {};
            window.ss.config = " . $this->owner->getClientConfig() . ";
            window.ss.config = " . $this->owner->/** @scrutinizer ignore-call */ getClientConfig() . ";
        ");

        $this->owner->customScript();
                      customScript();
    }

    /**
     * Generates the custom script for settings
     */
    public function customScript()
    {
        $radii = $this->owner->getShowRadius() ? $this->owner->getRadii() : [];
        $radii = $this->owner->getShowRadius() ? $this->owner->/** @scrutinizer ignore-call */ getRadii() : [];
        $radiiString = json_encode($radii);

        $categories = $this->owner->getUsedCategories();
        $categories = $this->owner->getUsedCategories();
        $categoriesString = $this->owner->categoriesString($categories);
        $categoriesString = $this->owner->categoriesString($categories);

        $unit = $this->owner->Unit ? $this->owner->Unit : 'm';

        // otherwise this is 0 or 1
        $clusters = $this->owner->Clusters ? 'true' : 'false';

        $autocomplete = $this->owner->Autocomplete ? 'true' : 'false';


        $stylePath = ModuleResourceLoader::singleton()->resolveURL(
            $this->owner->getMapStyle()
                          getMapStyle()
        );
        $searchMarkerIconPath = $this->owner->getSearchIconImage();
        $searchMarkerIconPath = $this->owner->getSearchIconImage();
        $markerIconPath = AddressDataExtension::getIconImage(true);

        if ($this->owner->SearchMarkerImageID) {

            $searchMarkerIconPath = $this->owner->SearchMarkerImage()->URL;
            $searchMarkerIconPath = $this->owner->/** @scrutinizer ignore-call */ SearchMarkerImage()->URL;
        }
        if ($this->owner->DefaultMarkerImageID) {

            $markerIconPath = $this->owner->DefaultMarkerImage()->URL;
            $markerIconPath = $this->owner->/** @scrutinizer ignore-call */ DefaultMarkerImage()->URL;
        }

        $clusterImages = json_encode($this->getClusterImages());

        // force to float
        $defaultLat = (float)$this->owner->DefaultLat;

        $defaultLng = (float)$this->owner->DefaultLng;


        Requirements::customScript("
            window.dynamic_locator = {
                'radii': {$radiiString},
                'categories': {$categoriesString},
                'unit': '{$unit}',
                'limit': {$this->owner->getLimit()},
                'limit': {$this->owner->/** @scrutinizer ignore-call */ getLimit()},
                'clusters': {$clusters},
                'mapStylePath': '{$stylePath}',
                'searchMarkerImagePath': '{$searchMarkerIconPath}',
                'markerImagePath': '{$markerIconPath}',
                'clusterImages': {$clusterImages},
                'defaultCenter': {
                    'lat': {$defaultLat},
                    'lng': {$defaultLng}
                },
                'autocomplete': {$autocomplete}
            };
        ", 'react-locator');
    }

    /**
     * Gets the maker icon image
     * @return null|string
     * @var boolean $svg if svgs should be included
     */
    public static function getSearchIconImage($svg = true)
    {
        $folders = [
            'client/dist/img/',
            'client/dist/images/',
            'dist/img/',
            'dist/images/',
            'img/',
            'images/',
        ];

        $extensions = [
            'png',
            'jpg',
            'jpeg',
            'gif',
        ];

        if ($svg === true) {
            array_unshift($extensions, 'svg');
        }

        $file = 'mapSearchIcon';

        foreach ($folders as $folder) {
            foreach ($extensions as $extension) {
                if ($icon = ThemeResourceLoader::inst()->findThemedResource(
                    "{$folder}{$file}.{$extension}",
                    SSViewer::get_themes()
                )) {
                    return ModuleResourceLoader::resourceURL($icon);
                }
            }
        }

        return false;

    }

    /**
     * @param string $path
     * @return bool
     */
    protected function isResourcePath($path)
    {
        $path = ltrim($path, '/');
        return substr($path, 0, strlen(RESOURCES_DIR)) === RESOURCES_DIR;
    }

    /**
     * @param string $path
     * @return bool|string
     */
    protected function getClusterImageFromPath($path)
    {
        // valid full url
        if (filter_var($path, FILTER_VALIDATE_URL)) {
            return $path;
        }

        if ($this->owner->isResourcePath($path)) {
        if ($this->owner->/** @scrutinizer ignore-call */ isResourcePath($path)) {
            return $path;
        }

        $icon = ThemeResourceLoader::inst()->findThemedResource($path, SSViewer::get_themes());
        if ($icon) {
            return ModuleResourceLoader::resourceURL($icon);
        }

        return false;
    }

    /**
     * @return array|bool
     */
    public function getClusterImages()
    {
        $iconPaths = $this->owner->getFailover()->config()->get('ClusterImages');
        $iconPaths = $this->owner->/** @scrutinizer ignore-call */ getFailover()->config()->get('ClusterImages');
        $icons = [];
        if (!$iconPaths) {
            return $icons;
        }

        foreach ($iconPaths as $path) {
            $iconPath = $this->owner->getClusterImageFromPath($path);
            $iconPath = $this->owner->getClusterImageFromPath($path);
            if ($iconPath) {
                $icons[] = $iconPath;
            }
        }

        return $icons;
    }

    /**
     * @param $categories
     *
     * @return string
     */
    public function categoriesString($categories)
    {
        $string = '[';
        for ($i = 0; $i < $categories->count(); $i++) {
            $cat = $categories[$i];
            $ID = $cat->ID;
            $Name = $cat->Name;
            $string .= "{
                'ID': {$ID},
                'Name': '{$Name}'
            }";

            if ($i !== $categories->count() - 1) {
                $string .= ',';
            }
        }
        $string .= ']';

        return $string;
    }

    /**
     * @return string
     */
    public function getClientConfig()
    {
        $token = SecurityToken::inst();

        $clientConfig = [
            'name' => get_class($this->owner),
            'url' => trim($this->owner->Link(), '/'),
            'url' => trim($this->owner->/** @scrutinizer ignore-call */ Link(), '/'),
            'baseUrl' => Director::baseURL(),
            'absoluteBaseUrl' => Director::absoluteBaseURL(),
            $token->getName() => $token->getValue(),
            'sections' => [],
            'debugging' => $this->owner->config()->get('debugging'),
            'debugging' => $this->owner->/** @scrutinizer ignore-call */ config()->get('debugging'),
        ];

        $clientConfig['sections'][] = Injector::inst()->get(LeftAndMain::class)->getClientConfig();

        $this->owner->extend('updateClientConfig', $clientConfig);
                      extend('updateClientConfig', $clientConfig);

        return Convert::raw2json($clientConfig);
        return /** @scrutinizer ignore-deprecated */ Convert::raw2json($clientConfig);
    }

    /**
     * Gets a JSON schema representing the search form.
     *
     * @param HTTPRequest $request

     * @return HTTPResponse
     */
    public function schema($request)
    public function schema(/** @scrutinizer ignore-unused */ $request)
    {
        return $this->getSchemaResponse("Locator.SearchForm", $this->owner->LocationSearch());
        return $this->getSchemaResponse("Locator.SearchForm", $this->owner->/** @scrutinizer ignore-call */ LocationSearch());
    }

    /**
     * Check if the current request has a X-Formschema-Request header set.
     * Used by conditional logic that responds to validation results
     *
     * @return bool
     */
    protected function getSchemaRequested()
    {
        $parts = $this->owner->getRequest()->getHeader(LeftAndMain::SCHEMA_HEADER);
        $parts = $this->owner->/** @scrutinizer ignore-call */ getRequest()->getHeader(LeftAndMain::SCHEMA_HEADER);
        return !empty($parts);
    }

    /**
     * Generate schema for the given form based on the X-Formschema-Request header value
     *
     * @param string $schemaID ID for this schema. Required.
     * @param Form $form Required for 'state' or 'schema' response
filter:
    dependency_paths: ["lib/*"]
     * @param ValidationResult $errors Required for 'error' response
     * @param array $extraData Any extra data to be merged with the schema response
     * @return HTTPResponse
     */
    protected function getSchemaResponse($schemaID, $form = null, ValidationResult $errors = null, $extraData = [])
filter:
    dependency_paths: ["lib/*"]
    {
        $parts = $this->owner->getRequest()->getHeader(LeftAndMain::SCHEMA_HEADER);
        $data = $this
            ->getFormSchema()
            ->getMultipartSchema($parts, $schemaID, $form, $errors);

        if ($extraData) {

            $data = array_merge($data, $extraData);
        }

        $response = new HTTPResponse(Convert::raw2json($data));
        $response = new HTTPResponse(/** @scrutinizer ignore-deprecated */ Convert::raw2json($data));
        $response->addHeader('Content-Type', 'application/json');
        return $response;
    }
}

dynamic / silverstripe-locator-frontend-react

Push — master ( 6ccdbd...5b2198 )

getClusterImageFromPath() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
