AppCtrlCustomContainer::editVisibility() - Code Metrics - capwelton/libapp - Measure and Improve Code Quality continuously with Scrutinizer

AppCtrlCustomContainer::editVisibility() D
last analyzed 2022-10-21 15:18 UTC

↳ Parent: AppCtrlCustomContainer
Complexity

Conditions	18
Paths	8
Size

Total Lines	92
Code Lines	58
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	1
Metric	Value
eloc	58
c	1
b	0
f	1
dl	0
loc	92
rs	4.8666
cc	18
nc	8
nop	1
How to fix Long Method Complexity

<?php

// -------------------------------------------------------------------------
// OVIDENTIA http://www.ovidentia.org
// Ovidentia is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// -------------------------------------------------------------------------
/**
 * @license http://opensource.org/licenses/gpl-license.php GNU General Public License (GPL)
 * @copyright Copyright (c) 2022 by SI4YOU ({@link https://www.siforyou.com})
 */
namespace Capwelton\LibApp\Ctrl;

use bab_charset;
use Capwelton\LibApp\Func_App;
use Capwelton\Widgets\Widgets\Form\WidgetForm;
filter:
    dependency_paths: ["lib/*"]
use Capwelton\Widgets\Widgets\Layout\WidgetVBoxLayout;
filter:
    dependency_paths: ["lib/*"]
use Capwelton\Widgets\Widgets\Item\WidgetLink;
filter:
    dependency_paths: ["lib/*"]
use Capwelton\LibApp\Ui\AppEditor;
use Capwelton\LibApp\Ui\Page\AppPage;
use Capwelton\LibApp\Set\AppRecordSet;
use Capwelton\LibApp\Set\AppCustomContainer;
use Capwelton\LibOrm\ORMRecord;
filter:
    dependency_paths: ["lib/*"]
use Capwelton\LibOrm\Interfaces\ORMBoolInterface;
filter:
    dependency_paths: ["lib/*"]
use Capwelton\LibOrm\MySql\ORMOneRelation;
filter:
    dependency_paths: ["lib/*"]

/**
 * This controller manages actions that can be performed on custom sections
 *
 * @method Func_App App()
 * @method self proxy()
 */
class AppCtrlCustomContainer extends AppCtrlRecord
{
    
    /**
     * @param string $itemId
     * @return WidgetVBoxLayout
     */
    public function availableDisplayFields($section = null, $itemId = null)
    {
        $W = bab_Widgets();
        $App = $this->App();
        
        $customSectionSet = $App->CustomContainerSet();
        
        $customSection = $customSectionSet->request($customSectionSet->id->is($section));
        
        $object = $customSection->object;
        $objectCtrl = $App->Controller()->$object(false);
        
        $allViewSections = $customSectionSet->select($customSectionSet->view->is($customSection->view)
            ->_AND_($customSectionSet->object->is($customSection->object)));
        
        $allViewFieldNames = array();
        foreach ($allViewSections as $viewSection){
            $fields = $viewSection->getFields();
            foreach ($fields as $field){
                $allViewFieldNames[$field['fieldname']] = $viewSection->view . ',' . $viewSection->rank . ',' . $viewSection->id;
            }
        }
        
        $box = $W->VBoxItems();
        if(isset($itemId)){
            $box->setId($itemId);
        }
        
        $box->addItem($W->Link($App->translate('Create new field'), $App->Controller()
            ->CustomField()
            ->add($customSection->object))
            ->/** @scrutinizer ignore-call */ add($customSection->object))
            ->setOpenMode(WidgetLink::OPEN_DIALOG_AND_RELOAD)
            ->addClass('widget-actionbutton', 'icon', \Func_Icons::ACTIONS_LIST_ADD)
            ->setSizePolicy(\Func_Icons::ICON_LEFT_SYMBOLIC));
        
        $availableFields = $objectCtrl->getAvailableDisplayFields();
        
        \bab_Sort::asort($availableFields, 'description', \bab_Sort::CASE_INSENSITIVE);
        
        foreach ($availableFields as $field){
            $fieldName = $field['name'];
            $fieldDescription = $field['description'];
            
            $used = isset($allViewFieldNames[$fieldName]);
            $box->addItem($W->VBoxItems($W->Link($fieldDescription, $this->proxy()
            $box->addItem($W->VBoxItems($W->Link($fieldDescription, /** @scrutinizer ignore-type */ $this->proxy()
                ->saveDisplayField($section, $fieldName))
                ->addClass('widget-close-dialog', ($used ? 'widget-strong' : ''))
                ->setTitle($fieldName)
                ->setAjaxAction(), $W->Hidden()
                ->setName(array(
                'sections',
                $field['name']
            )))
                ->setSizePolicy('widget-list-element'));
        }
        
        $box->addClass('widget-3columns');
        
        $box->setReloadAction($this->proxy()
            ->availableDisplayFields($section, $box->getId()));
        
        return $box;

    }
    
    /**
     */
    public function addDisplayField($section = null, $filter = null)
    {
        $App = $this->App();
        
        $page = $App->Ui()->Page();
        $page->setTitle($App->translate('Available fields'));
        
        $box = $this->availableDisplayFields($section);
        
        $page->addItem($box);
        return $page;
    }
    
    /**
     * @param int $section
     * @param string $fieldName
     * @return AppPage
     */
    public function editDisplayField($section, $fieldName)
    {
        $App = $this->App();
        $customSectionSet = $App->CustomContainerSet();
        
        $customSection = $customSectionSet->request($customSectionSet->id->is($section));
        
        $field = $customSection->getField($fieldName);
        
        if(! isset($field)){
            return null;
        }
        
        $W = bab_Widgets();
        
        $object = $customSection->object;
        $objectCtrl = $App->Controller()->$object(false);
        
        $fieldName = $field['fieldname'];
        $params = $field['parameters'];
        
        $availableFields = $objectCtrl->getAvailableDisplayFields();
        
        $field = $availableFields[$fieldName];
        $fieldDescription = $field['description'];
        if(substr($fieldName, 0, 1) !== '_'){
            $fieldDescription = $App->translate($fieldDescription);
        }
        
        if(empty($field)){
            // continue;
        }
        
        $page = $App->Ui()->Page();
        $page->setTitle($fieldDescription);
        
        $editor = new AppEditor($App);
        $editor->setHiddenValue('tg', $App->controllerTg);
        $editor->setHiddenValue('section', $section);
        $editor->setHiddenValue('fieldName', $fieldName);
        
        $box = $W->VBoxItems($W->LabelledWidget($App->translate('Type'), $W->Select()
            ->setName(array(
            'parameters',
            'type'
        ))
            ->addOption('', '')
            ->addOption('title1', $App->translate('Title 1'))
            ->addOption('title2', $App->translate('Title 2'))
            ->addOption('title3', $App->translate('Title 3'))), $W->LabelledWidget($App->translate('Label'), $W->LineEdit()
            ->setName(array(
            'parameters',
            'label'
        ))), $W->LabelledWidget($App->translate('Class'), $W->LineEdit()
            ->setName(array(
            'parameters',
            'classname'
        ))), $W->LabelledWidget($App->translate('Size policy'), $W->LineEdit()
            ->setName(array(
            'parameters',
            'sizePolicy'
        ))))
            ->setVerticalSpacing(1, 'em');
        
        $editor->setValues($params, array(
            'parameters'
        ));
        
        $editor->addItem($box);
        
        $editor->setSaveAction($this->proxy()
            ->saveDisplayField());
        
        $editor->isAjax = true;
        
        $page->addItem($editor);
        
        return $page;
    }
    
    /**
     * @param int $section
     * @param string $fieldName
     * @return boolean
     */
    public function saveDisplayField($section = null, $fieldName = null, $parameters = null)
    {
        $App = $this->App();
        $customSectionSet = $App->CustomContainerSet();
        
        $customSection = $customSectionSet->request($customSectionSet->id->is($section));
        $customSection->removeField($fieldName);
        $customSection->addField($fieldName, $parameters);
        $customSection->save();
        
        $this->addReloadSelector('.depends-custom-sections');
        
        return true;
    }
    
    /**
     * @param int $section
     * @param string $fieldName
     * @return boolean
     */
    public function removeDisplayField($section, $fieldName)
    {
        $App = $this->App();
        $customSectionSet = $App->CustomContainerSet();
        
        $customSection = $customSectionSet->request($customSectionSet->id->is($section));
        
        $customSection->removeField($fieldName);
        $customSection->save();
        $this->addReloadSelector('.depends-custom-sections');
        return true;
    }
    
    /**
     * @param string $view
     * @param int $id
     * @param string $object
     * @return AppPage
     */
    public function edit($view, $id = null, $object = null)
    {
        $App = $this->App();
        $W = bab_Widgets();
        
        $customSectionSet = $App->CustomContainerSet();
        if(isset($id)){
            $record = $customSectionSet->request($id);
        }
        else{
            $record = $customSectionSet->newRecord();
            $record->object = $object;
        }
        
        $page = $App->Ui()->Page();
        
        $page->setTitle($App->translate('Container'));
        $page->addClass('app-page-editor');
        
        $editor = new AppEditor($App);
        $editor->setHiddenValue('tg', $App->controllerTg);
        $editor->setHiddenValue('data[view]', $view);
        if($record->id){
            $editor->setHiddenValue('data[id]', $record->id);
        }
        $editor->setName('data');
        $editor->addItem($W->Hidden()
            ->setName('object'));
        
        $editor->addItem($W->LabelledWidget($App->translate('Name'), $W->LineEdit()
            ->setName('name')));
        
        $editor->addItem($W->LabelledWidget($App->translate('Element position'), $W->NumberEdit()
            ->setMin(0)
            ->setName('rank')));
        
        $sizePolicyClassnames = array(
            'col-md-1' => '1',
            'col-md-2' => '2',
            'col-md-3' => '3',
            'col-md-4' => '4',
            'col-md-5' => '5',
            'col-md-6' => '6',
            'col-md-7' => '7',
            'col-md-8' => '8',
            'col-md-9' => '9',
            'col-md-10' => '10',
            'col-md-11' => '11',
            'col-md-12' => '12',
            'left-panel' => 'left',
            'right-panel' => 'right'
        );
        
        $editor->addItem($W->LabelledWidget($App->translate('Size policy'), $W->Select()
            ->addOptions($sizePolicyClassnames)
            ->setName('sizePolicy')));
        $editor->addItem($W->LabelledWidget($App->translate('Layout'), $W->Select()
            ->addOptions(AppCustomContainer::getLayouts())
            ->setName('layout')));
        
        $editor->addItem($W->LabelledWidget($App->translate('Class'), $W->LineEdit()
            ->setName('classname')));
        
        $editor->setValues($record->getFormOutputValues(), array(
            'data'
        ));
        
        $editor->addButton($W->SubmitButton(/*'save'*/)
            ->validate(true)
            ->validate(/** @scrutinizer ignore-type */ true)
            ->setAction($this->proxy()
            ->setAction(/** @scrutinizer ignore-type */ $this->proxy()
            ->save())
            ->setAjaxAction()
            ->setLabel($App->translate('Save')));
        
        $editor->addButton($W->SubmitButton(/*'cancel'*/)
            ->addClass('widget-close-dialog')
            ->setLabel($App->translate('Cancel')));
        
        $page->addItem($editor);
        
        return $page;
    }
    
    /**
     * @param int $id
     * @return AppPage
     */
    public function editVisibility($id = null)
    {
        $App = $this->App();
        
        $page = $App->Ui()->Page();
        
        $page->setTitle($App->translate('Section visibility'));
        $page->addClass('app-page-editor');
        
        $recordSet = $this->getRecordSet();
        $record = $recordSet->request($id);
        
        $object = $record->object;
        if(empty($object)){
            $object = $record->container()->object;
        }
        if(strpos($object, $App->classPrefix) !== false){
            $object = str_replace($App->classPrefix, '', $object);
        }
        $object .= 'Set';
        
        /* @var $objectRecordSet AppRecordSet */
        $objectRecordSet = $App->$object();
        
        $editor = $App->Ui()->CriteriaEditor($objectRecordSet->all());
        $editor->setHiddenValue('data[id]', $record->id);
        $editor->setName('data');
        
        $manySets = $objectRecordSet->getHasManyRelations();
        $oneSets = $objectRecordSet->getHasOneRelations();
        
        if(! empty($record->visibilityCriteria)){
            $arrCriteria = json_decode($record->visibilityCriteria, true);
            
            $data = array();
            foreach ($arrCriteria as $fieldName => $operation){
                $data['field'] = $fieldName;
                foreach ($operation as $condition => $value){
                    $data['condition']['default'] = $condition;
                    $data['condition']['bool'] = $condition;
                    if(is_array($value)){
                        foreach ($value as $key => $subValue){
                            foreach ($manySets as $manyFieldName => $manyRelation){
                                if($key . 'Set' == $manyRelation->getForeignSetClassName()){
                                    foreach ($subValue as $subFieldName => $subConditions){
                                        if($subFieldName === '_foreignField'){
                                            continue;
                                        }
                                        $data['field'] = "{$manyFieldName}/{$subFieldName}";
                                        foreach ($subConditions as $subCondition => $subConditionValue){
                                            $data['condition']['default'] = $subCondition;
                                            $data['condition']['bool'] = $subCondition;
                                            $value = $subConditionValue;
                                        }
                                    }
                                    break;
                                }
                            }
                            foreach ($oneSets as $oneFieldName => $oneRelation){
                                if($key . 'Set' == $oneRelation->getForeignSetClassName()){
                                    foreach ($subValue as $subFieldName => $subConditions){
                                        if($subFieldName === '_foreignField'){
                                            continue;
                                        }
                                        $data['field'] = "{$oneFieldName}/{$subFieldName}";
                                        foreach ($subConditions as $subCondition => $subConditionValue){
                                            $data['condition']['default'] = $subCondition;
                                            $data['condition']['bool'] = $subCondition;
                                            $value = $subConditionValue;
                                        }
                                    }
                                    break;
                                }
                            }
                        }
                    }
                    $data['value'] = $value;
                }
            }
            
            $editor->setValues($data, array(
                'data'
            ));
        }
        
        $editor->setSaveAction($this->proxy()
            ->saveVisibility());
        $editor->isAjax = bab_isAjaxRequest();
        
        $page->addItem($editor);
        
        return $page;
    }
    
    /**
     * {@inheritdoc}
     * @see AppController::save()
     */
    public function save($data = null)
    {
        parent::save($data);
        
        $this->addReloadSelector('.depends-custom-sections');
        
        return true;
    }
    
    protected function preSave(ORMRecord $record, $data)
    {
        parent::preSave($record, $data);
        if(! isset($record->id) || empty($record->id)){
            $set = $record->getParentSet();
            $nbContainers = $set->select($set->all(array(
                $set->object->is($record->object),
                $set->view->is($record->view)
            )))
                ->count();
            $record->rank = $nbContainers + 1;
        }
    }
    
    /**
     * {@inheritdoc}
     * @see AppCtrlRecord::delete()
     */
    public function delete($id)
    {
        parent::delete($id);
        
        $this->addReloadSelector('.depends-custom-sections');
        
        return true;
    }
    
    /**
     * @param array $data
     */
    public function saveVisibility($data = null)
    {
        $App = $this->App();
        
        $recordSet = $this->getRecordSet();
        $record = $recordSet->request($data['id']);
        
        $object = $record->object;
        if(empty($object)){
            $object = $record->container()->object;
        }
        if(strpos($object, $App->classPrefix) !== false){
            $object = str_replace($App->classPrefix, '', $object);
        }
        $object .= 'Set';
        
        /* @var $objectRecordSet AppRecordSet */
        $objectRecordSet = $App->$object();
        
        $field = $data['field'];
        $condition = $data['condition'];
        
        if(strpos($field, '/') !== false){
            // The selected field is a hasMany or a hasOne relation
            list ($selectedRelation, $selectedField) = explode('/', $field);
            $classPrefix = $App->classPrefix;
            
            $manyRelations = $objectRecordSet->getHasManyRelations();
            foreach ($manyRelations as $manyRelation){
                if($selectedRelation != $manyRelation->getOwnerSetFieldName()){
                    continue;
                }
                $foreignSetName = str_replace($classPrefix, '', $manyRelation->getForeignSetClassName());
                $foreignSet = $App->$foreignSetName();
                
                $visibilityCriteria = '';
                
                if($foreignSet){
                    $selectedManyField = $foreignSet->$selectedField;
                    
                    if($selectedManyField instanceof ORMBoolInterface){
                        $condition = $condition['bool'];
                    }
                    else{
                        $condition = $condition['default'];
                    }
                    
                    $criteria = $objectRecordSet->id->in($selectedManyField->{$condition}($data['value']), $manyRelation->getForeignFieldName());
                    
                    $visibilityCriteria = $criteria->toJson();
                }
                break;
            }
            
            $oneRelations = $objectRecordSet->getHasOneRelations();
            foreach ($oneRelations as $oneRelation){
                /* @var $oneRelation ORMOneRelation*/
                if($selectedRelation != $oneRelation->getOwnerSetFieldName()){
                    continue;
                }
                $foreignSetClassName = $oneRelation->getForeignSetClassName();
                $foreignSetName = str_replace($classPrefix, '', $foreignSetClassName);
                $foreignSet = $App->$foreignSetName();
                
                $visibilityCriteria = '';
                
                if($foreignSet){
                    $selectedOneField = $foreignSet->$selectedField;
                    
                    if($selectedOneField instanceof ORMBoolInterface){
                        $condition = $condition['bool'];
                    }
                    else{
                        $condition = $condition['default'];
                    }
                    
                    $criteria = $objectRecordSet->$selectedRelation()->$selectedField->{$condition}($data['value']);
                    $visibilityCriteria = $criteria->toJson();
                }
                break;
            }
        }
        else{
            
            $field = $objectRecordSet->$field;
            
            if($field instanceof ORMBoolInterface){
                $condition = $condition['bool'];
            }
            else{
                $condition = $condition['default'];
            }
            
            $visibilityCriteria = '';
            
            if(! empty($condition)){
                $criteria = $field->{$condition}($data['value']);
                $visibilityCriteria = $criteria->toJson();
            }
        }
        
        $record->visibilityCriteria = $visibilityCriteria;

        
        $record->save();
        
        $this->addReloadSelector('.depends-custom-sections');
        
        return true;
    }
    
    /**
     * @param string $view
     * @param string $itemId
     * @return WidgetForm
     */
    public function containers($object, $view, $itemId = null)
    {
        $W = bab_Widgets();
        $App = $this->App();
        
        $customContainerCtrl = $App->Controller()->CustomContainer();
        $customSectionCtrlNoProxy = $App->Controller()->CustomSection(false);
        $customSectionCtrl = $customSectionCtrlNoProxy->proxy();
        
        $customContainerSet = $App->CustomContainerSet();
        $customContainers = $customContainerSet->select($customContainerSet->all($customContainerSet->object->is($object), $customContainerSet->view->is($view)));
        $customContainers->orderAsc($customContainerSet->rank);
        
        $containerBoxes = $W->Items();
        
        foreach ($customContainers as $customContainer){
            
            $menu = $W->HBoxItems($W->Link('', $customSectionCtrl->edit($customContainer->id))
                ->addClass('icon', \Func_Icons::ACTIONS_LIST_ADD)
                ->setOpenMode(WidgetLink::OPEN_DIALOG), $W->Link('', $customContainerCtrl->edit($view, $customContainer->id))
                ->addClass('icon', \Func_Icons::ACTIONS_DOCUMENT_EDIT)
                ->setOpenMode(WidgetLink::OPEN_DIALOG), $W->Link('', $customContainerCtrl->editVisibility($customContainer->id))
                ->addClass('icon', \Func_Icons::ACTIONS_SET_ACCESS_RIGHTS)
                ->setOpenMode(WidgetLink::OPEN_DIALOG), $W->Link('', $customContainerCtrl->confirmDelete($customContainer->id))
                ->addClass('icon', \Func_Icons::ACTIONS_EDIT_DELETE)
                ->setOpenMode(WidgetLink::OPEN_DIALOG)
                ->setDialogClass('box red'));
                ->/** @scrutinizer ignore-call */ setDialogClass('box red'));
            $menu->setSizePolicy(\Func_Icons::ICON_LEFT_16);
            
            $hasVisibilityBox = $W->FlowItems()->addClass('widget-100');
            if(! empty($customContainer->visibilityCriteria)){
                $hasVisibilityBox->addItem($W->HBoxItems($W->Label($App->translate('This container has a visibility condition')))
                    ->setSizePolicy('alert alert-warning widget-100pc'));
            }
            
            $containerBox = $W->VBoxItems($menu, $hasVisibilityBox, $customSectionCtrlNoProxy->sections($customContainer->id));
            
            $containerBoxes->addItem($containerBox->setSizePolicy($customContainer->sizePolicy)
                ->addClass($customContainer->classname));
        }
        
        if(isset($itemId)){
            $containerBoxes->setId($itemId);
        }
        
        $containerBoxes->setReloadAction($this->proxy()
            ->containers($object, $view, $containerBoxes->getId()));
        
        $containerBoxes->addClass('depends-custom-sections');
        
        return $containerBoxes;

    }
    
    /**
     * @param string $view
     */
    public function exportContainers($object, $view)
    {
        $App = $this->App();
        $customContainerSet = $App->CustomContainerSet();
        
        $customContainers = $customContainerSet->select($customContainerSet->view->is($view)
            ->_AND_($customContainerSet->object->is($object)));
        
        $customSectionSet = $App->CustomSectionSet();
        
        $containersValues = array();
        foreach ($customContainers as $customContainer){
            $values = $customContainer->getValues();
            unset($values['id']);
            unset($values['uuid']);
            unset($values['createdBy']);
            unset($values['createdOn']);
            unset($values['modifiedBy']);
            unset($values['modifiedOn']);
            unset($values['deletedBy']);
            unset($values['deletedOn']);
            unset($values['deleted']);
            $values['customSections'] = array();
            $customSections = $customSectionSet->select($customSectionSet->container->is($customContainer->id));
            foreach ($customSections as $customSection){
                $customSectionValues = $customSection->getValues();
                unset($customSectionValues['id']);
                unset($customSectionValues['uuid']);
                unset($customSectionValues['createdBy']);
                unset($customSectionValues['createdOn']);
                unset($customSectionValues['modifiedBy']);
                unset($customSectionValues['modifiedOn']);
                unset($customSectionValues['deletedBy']);
                unset($customSectionValues['deletedOn']);
                unset($customSectionValues['deleted']);
                unset($customSectionValues['container']);
                $customSectionValues['fields'] = $customSection->getFields();
                $values['customSections'][] = $customSectionValues;
            }
            $containersValues[] = $values;
        }
        
        header('Content-type: application/json');
        header('Content-Disposition: attachment; filename="' . $object . '.' . ($view === '' ? 'default' : $view) . '.json"' . "\n");
        if(bab_charset::getIso() != bab_charset::UTF_8){
            $containersValues = app_utf8Encode($containersValues);
        }
        $json = bab_json_encode($containersValues);
        $json = bab_convertStringFromDatabase($json, \bab_charset::UTF_8);
        
        die($json);

    }
    
    /**
     * @param string $view
     * @return AppPage
     */
    public function importContainersConfirm($object, $view = '')
    {
        $App = $this->App();
        $W = bab_Widgets();
        
        $page = $App->Ui()->Page();
        
        $page->setTitle($App->translate('Import containers layout'));
        
        $editor = new AppEditor($App);
        $editor->setHiddenValue('tg', $App->controllerTg);
        $editor->setHiddenValue('object', $object);
        $editor->isAjax = true;
        
        $editor->addItem($W->Label($App->translate('The existing view will be replaced'))
            ->setSizePolicy('alert alert-danger'));
        
        $editor->addItem($W->LabelledWidget($App->translate('View layout name'), $W->LineEdit()
            ->setValue($view), 'view'));
        
        $editor->addItem($W->LabelledWidget($App->translate('File'), $W->FilePicker(), 'containersfile'));
        
        $editor->setSaveAction($this->proxy()
            ->importContainers());
        
        $page->addItem($editor);
        
        return $page;
    }
    
    /**
     * @param string $view
     * @param string $containersfile
     * @return bool
     */
    public function importContainers($object = null, $view = null, $containersfile = null)
    {
        $this->requireSaveMethod();
        $App = $this->App();
        $W = bab_Widgets();
        
        $files = $W->FilePicker()->getFolder();
        $files->push('containersfile');
        $files->push($containersfile['uid']);
        
        $data = null;
        foreach ($files as $f){
            $data = file_get_contents($f->toString());
            break;
        }
        
        if(! isset($data)){
            $this->addError($App->translate('Unable to get file content'));
            return true;
        }
        
        $containersValues = json_decode($data, true);
        
        $App = $this->App();
        $customContainerSet = $App->CustomContainerSet();
        $customSectionSet = $App->CustomSectionSet();
        
        $customSectionSet->delete($customSectionSet->container->in($customContainerSet->view->is($view)
            ->_AND_($customContainerSet->object->is($object)), 'id'));
        $customContainerSet->delete($customContainerSet->view->is($view)
            ->_AND_($customContainerSet->object->is($object)));
        
        foreach ($containersValues as $containerValues){
            $customContainer = $customContainerSet->newRecord();
            $customContainer->setValues($containerValues);
            $customContainer->object = $object;
            $customContainer->view = $view;
            $customContainer->save();
            foreach ($containerValues['customSections'] as $sectionValues){
                $customSection = $customSectionSet->newRecord();
                $sectionValues['fields'] = json_encode($sectionValues['fields']);
                $customSection->setValues($sectionValues);
                $customSection->object = $object;
                $customSection->view = $view;
                $customSection->container = $customContainer->id;
                $customSection->save();
            }
        }
        
        $this->addReloadSelector('.depends-custom-sections');
        return true;
    }
    
    /**
     * @param string $view
     * @return bool
     */
    public function confirmDeleteContainers($object, $view)
    {
        $W = bab_Widgets();
        $App = $this->App();
        $Ui = $App->Ui();
        
        $page = $Ui->Page();
        
        $page->addClass('app-page-editor');
        $page->setTitle($App->translate('Delete view layout'));
        
        $form = new AppEditor($App);
        $form->setName('data');
        $form->isAjax = true;
        $form->setHiddenValue('tg', $App->controllerTg);
        $form->addItem($W->Title($App->translate('Confirm delete?'), 6));
        $form->addItem($W->Html(bab_toHtml($App->translate('It will not be possible to undo this deletion.'))));
        
        $confirmedAction = $this->proxy()->deleteContainers();
        $form->addItem($W->Hidden(null, 'object', $object));
        $form->addItem($W->Hidden(null, 'view', $view));
        $form->addButton($W->SubmitButton()
            ->setAjaxAction($confirmedAction)
            ->setAjaxAction(/** @scrutinizer ignore-type */ $confirmedAction)
            ->setLabel($App->translate('Delete')));
        $form->addButton($W->SubmitButton()
            ->setLabel($App->translate('Cancel'))
            ->addClass('widget-close-dialog'));
        $page->addItem($form);
        
        return $page;

    }
    
    /**
     * @param string $view
     * @return bool
     */
    public function deleteContainers($data = null)
    {
        $this->requireDeleteMethod();
        $App = $this->App();
        $customContainerSet = $App->CustomContainerSet();
        $customSectionSet = $App->CustomSectionSet();
        
        $containerCriteria = array(
            $customContainerSet->view->is($data['view']),
            $customContainerSet->object->is($data['object'])
        );
        
        $customSectionSet->delete($customSectionSet->container->in($customContainerSet->all($containerCriteria), 'id'));
        
        $customContainerSet->delete($customContainerSet->all($containerCriteria));
        
        $this->addToast($App->translate('The view layout has been deleted'));
        $this->addReloadSelector('.depends-custom-sections');
        
        return true;
    }
    
    /**
     * Display an user interface to edit containers associated to a specific object.
     *
     * @param string $object
     * @param string $view
     * @return AppPage
     */
    public function editContainers($object, $view)
    {
        $App = $this->App();
        $W = bab_Widgets();
        $Ui = $App->Ui();
        
        $page = $Ui->Page();
        
        $page->setTitle(sprintf($App->translate('Edit view layout %s'), $view));
        
        $toolbar = $Ui->Toolbar();
        
        $toolbar->addItem($W->Link($App->translate('Delete view layout'), $this->proxy()
            ->confirmDeleteContainers($object, $view))
            ->addClass('widget-actionbutton', 'icon', \Func_Icons::ACTIONS_EDIT_DELETE)
            ->setOpenMode(WidgetLink::OPEN_DIALOG)
            ->setDialogClass('box red'));
        
        $toolbar->addItem($W->Link($App->translate('Export view layout'), $this->proxy()
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
            ->exportContainers($object, $view))
            ->addClass('widget-actionbutton', 'icon', \Func_Icons::ACTIONS_DOCUMENT_UPLOAD));
        
        $toolbar->addItem($W->Link($App->translate('Import view layout'), $this->proxy()
            ->importContainersConfirm($object, $view))
            ->addClass('widget-actionbutton', 'icon', \Func_Icons::ACTIONS_DOCUMENT_DOWNLOAD)
            ->setOpenMode(WidgetLink::OPEN_DIALOG));
        
        $toolbar->addItem($W->Link($App->translate('Add a block'), $this->proxy()
            ->edit($view, null, $object))
            ->addClass('widget-actionbutton', 'icon', \Func_Icons::ACTIONS_LIST_ADD)
            ->setOpenMode(WidgetLink::OPEN_DIALOG));
        
        $form = $this->containers($object, $view);
        
        $page->addItem($toolbar);
        $page->addItem($form);
        
        return $page;
    }
    
    public function saveContainers($containers = null)
    {
        $App = $this->App();
        $customContainerSet = $App->CustomContainerSet();
        
        $containersFields = array();
        $containersRawFields = array();
        
        $rank = 0;
        $currentContainerId = 0;
        foreach (array_keys($containers) as $containerFieldId){
            
            if(substr($containerFieldId, 0, 1) === '#'){
                $currentContainerId = substr($containerFieldId, 1);
                
                $customContainer = $customContainerSet->request($customContainerSet->id->is($currentContainerId));
                
                $containersFields[$currentContainerId] = array();
                $containersRawFields[$currentContainerId] = $customContainer->getRawFields();
                
                $customContainer->rank = $rank;
                $rank ++;
                $customContainer->save();
                continue;
            }
            
            $containersFields[$currentContainerId][] = $containerFieldId;
        }
        
        foreach ($containersFields as $containerId => $containerFieldIds){
            foreach ($containerFieldIds as $containerFieldId){
                list ($srcContainerId, $srcfieldId) = explode('.', $containerFieldId);
                if(! isset($containersRawFields[$srcContainerId][$srcfieldId])){
                    return true;
                }
            }
        }
        
        foreach ($containersFields as $containerId => $containerFieldIds){
            $newRawFields = array();
            foreach ($containerFieldIds as $containerFieldId){
                list ($srcContainerId, $srcfieldId) = explode('.', $containerFieldId);
                $newRawFields[] = $containersRawFields[$srcContainerId][$srcfieldId];
            }
            
            $customContainer = $customContainerSet->request($customContainerSet->id->is($containerId));
            $customContainer->fields = implode(',', $newRawFields);
            $customContainer->save();
        }
        
        $this->addReloadSelector('.depends-custom-containers');
        
        return true;
    }
}

capwelton / libapp

AppCtrlCustomContainer::editVisibility() D last analyzed 2022-10-21 15:18 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

AppCtrlCustomContainer::editVisibility() D
last analyzed 2022-10-21 15:18 UTC
