datamanager::set_storage() - Code Metrics - Inspection of "Remove unused function" - flack/openpsa - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( a16483...3b8ba7 )

by Andreas
created 2020-07-05 14:03 UTC
datamanager::set_storage() A

↳ Parent: datamanager
Complexity

Conditions	6
Paths	12
Size

Total Lines	25
Code Lines	15
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	14
CRAP Score	6
Importance

Changes
Metric	Value
cc	6
eloc	15
nc	12
nop	2
dl	0
loc	25
ccs	14
cts	14
cp	1
crap	6
rs	9.2222
c	0
b	0
f	0
<?php
/**
 * @copyright CONTENT CONTROL GmbH, http://www.contentcontrol-berlin.de
 */

namespace midcom\datamanager;

use Symfony\Component\Form\FormFactoryInterface;
use Symfony\Component\Form\Form;
use midcom_core_dbaobject;
use midcom_core_context;
use midcom;
use Symfony\Component\Translation\Translator;
use midcom\datamanager\extension\transformer\multipleTransformer;
use midcom\datamanager\storage\recreateable;
use midcom\datamanager\extension\type\schemaType;
use midcom\datamanager\extension\type\toolbarType;
use midcom\datamanager\storage\container\container;
use midcom\datamanager\storage\container\dbacontainer;

/**
 * Experimental datamanager class
 */
class datamanager
{
    private $schemadb;

    /**
     * @var schema
     */
    private $schema;

    /**
     * @var storage\container\container
     */
    private $storage;

    /**
     * @var array
     */
    private $defaults = [];

    /**
     * @var renderer
     */
    private $renderer;

    /**
     * @var Form
     */
    private $form;

    public function __construct(schemadb $schemadb)
    {
        $this->schemadb = $schemadb;
    }

    private static function get_factory() : FormFactoryInterface
    {
        return midcom::get()->getContainer()->get('form.factory');
    }

    public static function from_schemadb($path) : self
    {
        return new static(schemadb::from_path($path));
    }

    public function set_defaults(array $defaults) : self
    {
        $this->defaults = $defaults;
        return $this;
    }

    /**
     * @param midcom_core_dbaobject $storage
     * @param string $schema
     */
    public function set_storage(midcom_core_dbaobject $storage = null, $schemaname = null) : self
    {
        if (   $schemaname === null
            && !empty($storage->id)) {
            $schemaname = $storage->get_parameter('midcom.helper.datamanager2', 'schema_name');
            $schemaname = $storage->get_parameter('midcom.helper.datamanager2', 'schema_name');
        }

        $this->set_schema($schemaname);

        $defaults = array_merge($this->schema->get_defaults(), $this->defaults);
        if ($storage === null) {
            $this->storage = new storage\container\nullcontainer($this->schema, $defaults);
        } else {
            $this->storage = new storage\container\dbacontainer($this->schema, $storage, $defaults);
        }

        if ($this->form !== null) {
            if ($this->form->isSubmitted()) {
                $this->form = null;
            } else {
                $this->form->setData($this->storage);
            }
        }

        return $this;
    }

    private function set_schema($name)
    {
        if ($name && !$this->schemadb->has($name)) {
            debug_add("Given schema name {$name} was not found, reverting to default.", MIDCOM_LOG_INFO);
            $name = null;
        }

        $schema = ($name) ? $this->schemadb->get($name) : $this->schemadb->get_first();
        if ($this->schema !== null && $this->schema->get_name() !== $schema->get_name()) {
            $this->form = null;
        }
        $this->schema = $schema;
    }

    /**
     * @param string $name
     */
    public function get_schema($name = null) : schema
    {
        if ($name) {
            return $this->schemadb->get($name);
        }
        if ($this->schema === null) {
            $this->set_schema($name);
        }
        return $this->schema;
    }

    public function get_storage() : container
    {
        if (!$this->storage) {
            $this->set_storage(null);
        }
        return $this->storage;
    }

    public function get_renderer($template = null, $skip_empty = false) : renderer
    {
        if ($this->renderer === null) {
            $this->renderer = new renderer(new engine);
            $this->renderer->set_l10n($this->schema->get_l10n());
        }
        if ($template) {
            if (is_string($template)) {
                $config = \midcom_baseclasses_components_configuration::get('midcom.datamanager', 'config');
                $templates = $config->get('templates');
                if (!array_key_exists($template, $templates)) {
                    throw new \midcom_error('Template ' . $template . ' not found in config');
                }
                $template = new $templates[$template]($this->renderer, $skip_empty);
            }
            $view = $this->get_form()->createView();
            $this->renderer->set_template($view, $template);
        }
        return $this->renderer;
    }

    /**
     * @param string $name
     */
    public function get_controller($name = null) : controller
    {
        return new controller($this, $name);
    }

    /**
     * @param string $name
     * @param boolean $reset
     */
    public function get_form($name = null, $reset = false) : Form
    {
        if ($reset) {
            $this->form = null;
        }
        if ($name == null) {

            $name = midcom_core_context::get()->get_key(MIDCOM_CONTEXT_COMPONENT);
            // Replace the dots in the component name with underscores
            $name = midcom::get()->componentloader->path_to_prefix($name);
            $name = midcom::get()->componentloader->path_to_prefix(/** @scrutinizer ignore-type */ $name);
        }
        if (!$name) {
            // Fallback for componentless operation
            $name = 'midcom_helper_datamanager2';
        }

        if (   $this->form === null
            || $this->form->getName() != $name) {
            $config = [
                'schema' => $this->get_schema()
            ];
            $builder = self::get_factory()->createNamedBuilder($name, schemaType::class, null, $config);
            $storage = $this->get_storage();

            $config = [
                'operations' => $this->schema->get('operations'),
                'index_method' => 'noindex',
                'is_create' => $storage instanceof dbacontainer && empty($storage->get_value()->id)
            ];

            $builder->add('form_toolbar', toolbarType::class, $config);

            $this->form = $builder->getForm()
                ->setData($storage);
        }
        return $this->form;
    }

    public function get_content_raw() : array
    {
        $ret = [];

        foreach ($this->storage as $field => $value)
        {
            $ret[$field] = $value->get_value();
            $config = $this->schema->get_field($field);
            if (!empty($config['type_config']['allow_multiple'])) {
                $transformer = new multipleTransformer($config);
                $ret[$field] = $transformer->transform($ret[$field]);
            }
        }

        return $ret;
    }

    public function get_content_csv() : array
    {
        $ret = [];

        $renderer = $this->get_renderer('csv');
        foreach ($renderer->get_view()->children as $name => $value) {
            if ($name == 'form_toolbar') {
                continue;
            }
            $ret[$name] = $renderer->widget($value);
        }

        return $ret;
    }

    public function get_content_html() : array
    {
        $ret = [];

        $renderer = $this->get_renderer('view');
        foreach ($renderer->get_view()->children as $name => $value) {
            if ($name == 'form_toolbar') {
                continue;
            }
            $ret[$name] = $renderer->widget($value);
        }
        return $ret;
    }

    public function display_view($skip_empty = false)
    {
        $renderer = $this->get_renderer('view', $skip_empty);
        echo $renderer->block($renderer->get_view(), 'form');
    }

    public function recreate() : bool
    {
        $ret = true;
        foreach ($this->storage as $field) {
            if (   $field instanceof recreateable
                && !$field->recreate()) {
                $ret = false;
            }
        }
        return $ret;
    }
}

flack / openpsa

Push — master ( a16483...3b8ba7 )

datamanager::set_storage() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
