DNADesign\Elemental\Controllers\ElementalAreaController

Complexity

Total Complexity

19

Size/Duplication

Total Lines	159
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	getClientConfig()	0	10	1
A	getElementForm()	0	17	2
A	elementForm()	0	13	4
A	removeNamespacesFromFields()	0	14	3
B	apiSaveForm()	0	57	9

<?php

namespace DNADesign\Elemental\Controllers;

use DNADesign\Elemental\Forms\EditFormFactory;
use DNADesign\Elemental\Models\BaseElement;
use Exception;
use Psr\Log\LoggerInterface;
use SilverStripe\Admin\LeftAndMain;
use SilverStripe\Control\HTTPRequest;
use SilverStripe\Control\HTTPResponse;
use SilverStripe\Control\HTTPResponse_Exception;
use SilverStripe\Core\Convert;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\Forms\Form;
use SilverStripe\Security\SecurityToken;

/**
 * Controller for "ElementalArea" - handles loading and saving of in-line edit forms in an elemental area in admin
 */
class ElementalAreaController extends LeftAndMain
{
    private static $url_segment = 'elemental-area';

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

    private static $ignore_menuitem = true;

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

    private static $url_handlers = [

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

        // API access points with structured data
        'POST api/saveForm/$ID' => 'apiSaveForm',
    ];

    private static $allowed_actions = [

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

        'elementForm',
        'schema',
        'apiSaveForm',
    ];

    public function getClientConfig()
    {
        $clientConfig = parent::getClientConfig();
        $clientConfig['form']['elementForm'] = [
            'schemaUrl' => $this->Link('schema/elementForm'),
            'saveUrl' => $this->Link('api/saveForm'),
            'saveMethod' => 'post',
            'payloadFormat' => 'json',
        ];
        return $clientConfig;
    }

    /**
     * @param HTTPRequest|null $request
     * @return Form
     * @throws HTTPResponse_Exception
     */
    public function elementForm(HTTPRequest $request = null)
    {
        // Get ID either from posted back value, or url parameter
        if (!$request) {
            $this->jsonError(400);
            return null;
        }
        $id = $request->param('ID');
        if (!$id) {
            $this->jsonError(400);
            return null;
        }
        return $this->getElementForm($id) ?: $this->jsonError(404);

$id of type string is incompatible with the type integer expected by parameter $elementID of DNADesign\Elemental\Controllers\ElementalAreaController::getElementForm().

    }

    /**
     * @param int $elementID
     * @return Form|null Returns null if no element exists for the given ID
     */
    public function getElementForm($elementID)
    {
        $scaffolder = Injector::inst()->get(EditFormFactory::class);
        $element = BaseElement::get()->byID($elementID);

        if (!$element) {

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

            return null;
        }

        /** @var Form $form */
        $form = $scaffolder->getForm(
            $this,
            'ElementForm_'.$elementID,
            ['Record' => $element]
        );

        return $form;
    }

    /**
     * Save an inline edit form for a block
     *
     * @param HTTPRequest $request
     * @return HTTPResponse|null JSON encoded string or null if an exception is thrown
     * @throws HTTPResponse_Exception
     */
    public function apiSaveForm(HTTPRequest $request)
    {
        // Validate required input data
        if (!isset($this->urlParams['ID'])) {
            $this->jsonError(400);
            return null;
        }

        $data = Convert::json2array($request->getBody());
        if (empty($data)) {
            $this->jsonError(400);
            return null;
        }

        // Inject request body as request vars
        foreach ($data as $key => $value) {
            $request->offsetSet($key, $value);
        }

        // Check security token
        if (!SecurityToken::inst()->checkRequest($request)) {
            $this->jsonError(400);
            return null;
        }

        /** @var BaseElement $element */
        $element = BaseElement::get()->byID($this->urlParams['ID']);
        // Ensure the element can be edited by the current user
        if (!$element || !$element->canEdit()) {

$element is of type DNADesign\Elemental\Models\BaseElement, thus it always evaluated to true. If $element can have other possible types, add them to src/Controllers/ElementalAreaController.php:125

            $this->jsonError(403);
            return null;
        }

        // Remove the pseudo namespaces that were added by the form factory
        $data = $this->removeNamespacesFromFields($data, $element->ID);

It seems like $data can also be of type boolean; however, parameter $data of DNADesign\Elemental\Controllers\ElementalAreaController::removeNamespacesFromFields() does only seem to accept array, maybe add an additional type check?

        try {
            $updated = false;
            $element->update($data);
            // Check if anything will actually be changed before writing
            if ($element->isChanged()) {
                $element->write();
                // Track changes so we can return to the client
                $updated = true;
            }
        } catch (Exception $ex) {
            Injector::inst()->get(LoggerInterface::class)->debug($ex->getMessage());

            $this->jsonError(500);
            return null;
        }

        $body = Convert::raw2json([
            'status' => 'success',
            'updated' => $updated,
        ]);
        return HTTPResponse::create($body)->addHeader('Content-Type', 'application/json');
    }

    /**
     * Remove the pseudo namespaces that were added to form fields by the form factory
     *
     * @param array $data
     * @param int $elementID
     * @return array
     */
    protected function removeNamespacesFromFields(array $data, $elementID)
    {
        $output = [];
        $template = sprintf(EditFormFactory::FIELD_NAMESPACE_TEMPLATE, $elementID, '');
        foreach ($data as $key => $value) {
            // Only look at fields that match the namespace template
            if (substr($key, 0, strlen($template)) !== $template) {
                continue;
            }

            $fieldName = substr($key, strlen($template));
            $output[$fieldName] = $value;
        }
        return $output;
    }
}