Blast\Bundle\CoreBundle\Admin\Traits\Mapper::addContent()

Complexity

Conditions	54
Paths	13896

Size

Total Lines	224
Code Lines	121

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    protected function addContent(BaseMapper $mapper, $group)
    {
        // helper links
        $this->parseHelperLinks();

        // flat organization (DatagridMapper / ListMapper...)
        if (!$mapper instanceof BaseGroupedMapper) {
            //list actions
            $this->addActions();

It seems like addActions() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            $this->removeActions();

It seems like removeActions() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            // options pre-treatment
            $options = [];
            if (isset($group['_options'])) {
                $options = $group['_options'];
                unset($group['_options']);
            }

            // content
            foreach ($group as $add => $opts) {
                $this->addField($mapper, $add, $opts);
            }

            // options
            if (isset($options['fieldsOrder'])) {
                $mapper->reorder($options['fieldsOrder']);
            }

            // extra templates
            $this->parseExtraTemplates();

            return $mapper;
        }

        $fcts = [
            'tabs' => $mapper instanceof ShowMapper ?
            ['getter' => 'getShowTabs', 'setter' => 'setShowTabs'] :
            ['getter' => 'getFormTabs', 'setter' => 'setFormTabs'],
            'groups' => $mapper instanceof ShowMapper ?
            ['getter' => 'getShowGroups', 'setter' => 'setShowGroups'] :
            ['getter' => 'getFormGroups', 'setter' => 'setFormGroups'],
        ];

        // if a grouped organization can be shapped
        // options
        $tabsOptions = null;
        if (isset($group['_options'])) {
            $tabsOptions = $group['_options'];
            unset($group['_options']);
        }

        // content
        foreach ($group as $tab => $tabcontent) { // loop on content...
            if (self::arrayDepth($tabcontent) < 1) {
                // direct add
                $this->addField($mapper, $tab, $tabcontent);
                $mapper->end()->end();
            } else {
                // groups/withs order
                $groupsOrder = null;
                if (isset($tabcontent['_options']['groupsOrder'])) {
                    $groupsOrder = $tabcontent['_options']['groupsOrder'];
                    unset($tabcontent['_options']['groupsOrder']);
                }

                $endgroup = $endtab = false;

                // tab
                if (!empty($tabcontent['_options']['hideTitle']) || $mapper instanceof ShowMapper && !$this->forceTabs) {
                    // display tabs as groups
                    $tabs = $this->{$fcts['tabs']['getter']}();
                    $groups = $this->{$fcts['groups']['getter']}();
                    if (isset($tabs[$tab])) {
                        $tabs[$tab]['auto_created'] = true;
                        $this->{$fcts['tabs']['setter']}($tabs);

                        foreach ($groups as $groupkey => $group) {
                            if (!isset($groups[$group['name']])) {
                                $groups[$group['name']] = $group;
                                unset($groups[$groupkey]);
                            }
                        }
                        $this->{$fcts['groups']['setter']}($groups);
                    }
                } else {
                    $mapper->tab($tab, isset($tabcontent['_options']) ? $tabcontent['_options'] : []);
                    $endtab = true;
                }

                // adding count of collections items in tab
                if (isset($tabcontent['_options']['countChildItems']) && is_array($tabcontent['_options']['countChildItems'])) {
                    $tabs = $this->{$fcts['tabs']['getter']}();
                    if (strpos($tabs[$tab]['class'], 'countable-tab') === false) {
                        $tabs[$tab]['class'] .= ' countable-tab';

                        foreach ($tabcontent['_options']['countChildItems'] as $fieldToCount) {
                            if (strpos($tabs[$tab]['class'], 'count-' . $fieldToCount) === false) {
                                $tabs[$tab]['class'] .= ' count-' . $fieldToCount;
                            }
                        }

                        $this->{$fcts['tabs']['setter']}($tabs);
                    }
                }

                // clearing tabcontent options
                if (isset($tabcontent['_options'])) {
                    unset($tabcontent['_options']);
                }

                $finalOrder = null;

$finalOrder is not used, you could remove the assignment.

                // with
                if (self::arrayDepth($tabcontent) > 0) {
                    foreach ($tabcontent as $with => $withcontent) {
                        $opt = isset($withcontent['_options']) ? $withcontent['_options'] : [];
                        $finalOrder = (isset($opt['fieldsOrder']) ? $opt['fieldsOrder'] : null);

                        if (empty($opt['hideTitle'])) {
                            $endtab = true;
                            $endgroup = true;
                            $mapper->with($with, $opt);
                        }
                        if (isset($withcontent['_options'])) {
                            unset($withcontent['_options']);
                        }

                        // final adds
                        if (self::arrayDepth($withcontent) > 0) {
                            foreach ($withcontent as $name => $options) {
                                $fieldDescriptionOptions = [];
                                if (isset($options['_options'])) {
                                    $fieldDescriptionOptions = $options['_options'];
                                    unset($options['_options']);
                                }
                                $this->addField($mapper, $name, $options, $fieldDescriptionOptions);
                                $endgroup = $endtab = true;
                            }
                        }

                        if ($finalOrder != null) {
                            $mapper->reorder($finalOrder);
                        }

                        if ($endgroup) {
                            $mapper->end();
                        }
                    }
                }

                // order groups / withs (using tabs, because they are prioritary at the end)
                if (isset($groupsOrder)) {
                    // preparing
                    $otabs = $mapper->getAdmin()->{$fcts['tabs']['getter']}();
                    $groups = $mapper->getAdmin()->{$fcts['groups']['getter']}();

$groups is not used, you could remove the assignment.

                    // pre-ordering
                    $newgroups = [];
                    $buf = empty($otabs[$tab]['auto_created']) ? "$tab." : '';
                    foreach ($groupsOrder as $groupname) {
                        if (isset($otabs[$tab]) && in_array("$buf$groupname", $otabs[$tab]['groups'])) {
                            $newgroups[] = "$buf$groupname";
                        }
                    }

                    // ordering tabs
                    foreach (empty($otabs[$tab]['groups']) ? [] : $otabs[$tab]['groups'] as $groupname) {
                        if (!in_array($groupname, $newgroups)) {
                            $newgroups[] = $groupname;
                        }
                    }
                    $otabs[$tab]['groups'] = $newgroups;

                    // "persisting"
                    $mapper->getAdmin()->{$fcts['tabs']['setter']}($otabs);
                }

                if ($endtab) {
                    $mapper->end();
                }
            }
        }

        // ordering tabs
        if (isset($tabsOptions['tabsOrder']) && $tabs = $this->{$fcts['tabs']['getter']}()) {
            $newtabs = [];
            foreach ($tabsOptions['tabsOrder'] as $tabname) {
                if (isset($tabs[$tabname])) {
                    $newtabs[$tabname] = $tabs[$tabname];
                }
            }
            foreach ($tabs as $tabname => $tab) {
                if (!isset($newtabs[$tabname])) {
                    $newtabs[$tabname] = $tab;
                }
            }
            $this->{$fcts['tabs']['setter']}($newtabs);
        }

        // ordering the ShowMapper
        if ($mapper instanceof ShowMapper) {
            foreach ($group as $tabName => $tabContent) {
                $tabOptions = null;
                if (isset($tabContent['_options'])) {
                    $tabOptions = $tabContent['_options'];
                    unset($tabContent['_options']);
                }

                if (isset($tabOptions['groupsOrder'])) {
                    $tabs = $this->{$fcts['tabs']['getter']}();
                    $groups = $this->{$fcts['groups']['getter']}();

                    $groupOrder = $tabOptions['groupsOrder'];

                    $properOrderedArray = array_merge(array_flip($groupOrder), $groups);

                    $this->{$fcts['groups']['setter']}($properOrderedArray);
                    $this->{$fcts['tabs']['setter']}($tabs);
                }
            }
        }

        return $mapper;
    }