PhpTek\JSONText\Extension\JSONTextExtension

Complexity

Total Complexity

20

Size/Duplication

Total Lines	115
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	3
B	onBeforeWrite()	0	25	6
A	updateJSON()	0	20	4
B	updateCMSFields()	0	28	7

<?php

/**
 * This {@link DataExtension} allows you to declare arbitrary input fields in
 * your getCMSFields() methods without them ever going near an equivalent DBField.
 *
 * The SilverStripe default gives you one DBField for every input field declared
 * in getCMSFields(). This extension however allows you to use a single blob
 * of JSON, stored in a single {@link JSONTextField} and manage each key=>value pair
 * from individual form input fields, without needing to declare equivalent or further
 * database fields. All you need to do is add a `$json_field_map` config static to
 * your model (See below).
 *
 * Notes:
 * - Untested on non CHAR DB field-types (v0.8)
 * - Only works for single dimensional JSON data
 *
 * <code>
 * private static $db = [
 *      'TestJSON' => JSONText::class,
 * ];
 *
 * private static $json_field_map = [
 *      'TestJSON' => ['TestField1', 'TestField2']
 * ];
 *
 * public function getCMSFields()
 * {
 *      $fields = parent::getCMSFields();
 *      $fields->addFieldsToTab('Root.Main', [
 *          TextField::create('TestField1', 'Test 1'),
 *          TextField::create('TestField2', 'Test 2'),
 *          TextField::create('TestJSON', 'Some JSON') // Uses a TextField for demo, normally this would be hidden from CMS users
 *      ]);
 *
 *      return $fields;
 * }
 * </code>
 *
 * @package jsontext
 * @subpackage control
 * @author Russell Michell <russ@theruss.com>
 */

namespace PhpTek\JSONText\Extension;

use PhpTek\JSONText\Exception\JSONTextException;
use PhpTek\JSONText\ORM\FieldType\JSONText;
use SilverStripe\CMS\Controllers\CMSPageEditController;
use SilverStripe\Control\Controller;
use SilverStripe\Control\Director;
use SilverStripe\ORM\DataExtension;

class JSONTextExtension extends DataExtension
{

    public function __construct()
    {
        // Helpful class applicability message
        if (!Director::is_cli() && !class_exists(CMSPageEditController::class)) {
            $msg = 'Please install the silverstripe/cms package in order to use this extension.';
            throw new JSONTextException($msg);
        }

        return parent::__construct();

Constructors do not have meaningful return values, anything that is returned from here is discarded. Are you sure this is correct?

    }

    /**
     * Pre-process incoming CMS POST data, and modify any available {@link JSONText}
     * data for presentation in "headless" input fields.
     *
     * @return null
     */
    public function onBeforeWrite()
    {
        parent::onBeforeWrite();

        $owner = $this->getOwner();
        $controller = Controller::curr();
        $postVars = $controller->getRequest()->postVars();
        $fieldMap = $owner->config()->get('json_field_map');
        $doUpdate = (
            count($postVars) &&
            !empty($fieldMap) &&
            in_array(get_class($controller), [CMSPageEditController::class])
        );

        if (!$doUpdate) {
            return null;
        }

        // Could also use DataObject::getSchema()->fieldSpecs()
        foreach ($owner->config()->get('db') as $field => $type) {
            if ($type === JSONText::class) {
                $this->updateJSON($postVars, $owner);
            }
        }
    }

    /**
     * Called from {@link $this->onBeforeWrote()}. Inserts or updates each available
     * JSONText DB field with the appropriate input-field data, as per the model's
     * "json_field_map" config static.
     *
     * @param  array $postVars
     * @param  DataObject $owner
     * @return void
     * @throws JSONTextException
     */
    public function updateJSON(array $postVars, $owner)
    {
        $jsonFieldMap = $owner->config()->get('json_field_map');

        foreach ($jsonFieldMap as $jsonField => $mappedFields) {
            $jsonFieldData = [];

            foreach ($mappedFields as $fieldName) {
                if (!isset($postVars[$fieldName])) {
                    $msg = sprintf('%s doesn\'t exist in POST data.', $fieldName);
                    throw new JSONTextException($msg);
                }

                $jsonFieldData[$fieldName] = $postVars[$fieldName];
            }

            $fieldValue = singleton(JSONText::class)->toJson($jsonFieldData);
            $owner->setField($jsonField, $fieldValue);
        }
    }

    /**
     * The CMS input fields declared in the json_field_map static, are not DB-backed,
     * by virtue of this extension, they are backed by specific values represented
     * in the relevant JSON data. Therefore we need to pre-populate each such field's
     * value.
     *
     * @param  FieldList $fields
     * @return void
     */
    public function updateCMSFields(\SilverStripe\Forms\FieldList $fields)
    {
        $owner = $this->getOwner();
        $jsonFieldMap = $owner->config()->get('json_field_map');

        if (empty($jsonFieldMap)) {
            return;
        }

        foreach ($jsonFieldMap as $jsonField => $mappedFields) {
            if (!$owner->getField($jsonField)) {
                continue;
            }

            $jsonFieldObj = $owner->dbObject($jsonField);

            foreach ($mappedFields as $fieldName) {
                if (!$fieldValue = $jsonFieldObj->query('->>', $fieldName)) {
                    continue;
                }

                if ($fieldValue = array_values($jsonFieldObj->toArray($fieldValue))) {
                    $fieldValue = $fieldValue[0];
                    $owner->setField($fieldName, $fieldValue);
                }
            }
        }
    }
}