basereport.php

<?php
 
namespace Bitrix\Report\VisualConstructor\Handler;
use Bitrix\Main\Localization\Loc;
use Bitrix\Report\VisualConstructor\Config\Common;
use Bitrix\Report\VisualConstructor\Entity\Report;
use Bitrix\Report\VisualConstructor\Fields\Base as BaseFormField;
use Bitrix\Report\VisualConstructor\Fields\Div;
use Bitrix\Report\VisualConstructor\Fields\Valuable\CustomDropDown;
use Bitrix\Report\VisualConstructor\Fields\Valuable\BaseValuable;
use Bitrix\Report\VisualConstructor\Fields\Valuable\DropDown;
use Bitrix\Report\VisualConstructor\Fields\Valuable\IValuable;
use Bitrix\Report\VisualConstructor\Helper\Category;
use Bitrix\Report\VisualConstructor\IReportData;
use Bitrix\Report\VisualConstructor\RuntimeProvider\CategoryProvider;
use Bitrix\Report\VisualConstructor\RuntimeProvider\ReportProvider;
use Bitrix\Report\VisualConstructor\RuntimeProvider\ViewProvider;
 
use Bitrix\Report\VisualConstructor\Handler\Base as BaseHandler;
 
 
abstract class BaseReport extends BaseHandler implements IReportData
{
    private $title;
    private $categoryKey;
    private $unitKey;
    private $weight = 0;
 
    private $report;
    private $calculatedData;
    private $widgetHandler;
 
    public function __construct()
    {
        $report = new Report();
        $report->setReportHandler($this);
        $this->setReport($report);
        $this->setTitle(Loc::getMessage('WITHOUT_DATA'));
    }
 
    public function getCollectedFormElements()
    {
        parent::getCollectedFormElements();
        $this->getView()->collectReportHandlerFormElements($this);
        return $this->getFormElements();
    }
 
    protected function collectFormElements()
    {
        $mainContainer = new Div();
        $mainContainer->setKey('main_container');
        if ($this->getConfiguration('color'))
        {
            $mainContainer->addInlineStyle('background-color', $this->getConfiguration('color')->getValue() . '5f');
        }
        else
        {
            $reportHandlersCount = count($this->getWidgetHandler()->getReportHandlers());
            $mainContainer->addInlineStyle('background-color', $this->getView()->getReportDefaultColor($reportHandlersCount) . '5f');
        }
        $mainContainer->addClass('report-configuration-main');
        $mainContainer->addAssets(array(
            'css' => array('/bitrix/js/report/css/visualconstructor/configmain.css')
        ));
        $this->addFormElement($mainContainer->start());
        $fieldListContainer = new Div();
        $fieldListContainer->setKey('field_list_container');
        $fieldListContainer->addClass('report-configuration-field-list');
        $this->addFormElement($fieldListContainer->start());
 
        $reportHandlerSelectContainer = new Div();
        $reportHandlerSelectContainer->setKey('report_handler_select_container');
        $reportHandlerSelectContainer->addClass('report-configuration-row');
        $reportHandlerSelectContainer->addClass('report-configuration-no-padding-bottom');
        $categorySelectField = $this->getReportHandlerCategoryField();
        $reportHandlerSelectField = $this->getReportHandlerSelectField($categorySelectField->getValue());
 
        $reportHandlerSelectField->addJsEventListener($categorySelectField, $categorySelectField::JS_EVENT_ON_CHANGE, array(
            'class' => 'BX.Report.VisualConstructor.FieldEventHandlers.ReportHandlerSelect',
            'action' => 'categorySelected'
        ));
        $reportHandlerSelectField->addAssets(array(
            'js' => array('/bitrix/js/report/js/visualconstructor/fields/reporthandlerselect.js')
        ));
 
        $this->addFormElement($reportHandlerSelectContainer->start());
            $this->addFormElement($categorySelectField);
            $this->addFormElement($reportHandlerSelectField);
 
        $whatWillCalculateField = $this->getCalculateField();
 
        $viewCompatibleDataType = $this->getView()->getCompatibleDataType();
 
        if (in_array($viewCompatibleDataType, array(
            Common::MULTIPLE_REPORT_TYPE,
            Common::MULTIPLE_GROUPED_REPORT_TYPE,
            Common::MULTIPLE_BI_GROUPED_REPORT_TYPE,
        )))
        {
            $groupingField = $this->getGroupingField($whatWillCalculateField);
            $this->addFormElement($groupingField);
            $widgetHandler = $this->getWidgetHandler();
            $previewBlock = $widgetHandler->getFormElement('view_type');
            $previewBlock->addJsEventListener($groupingField, $groupingField::JS_EVENT_ON_CHANGE, array(
                'class' => 'BX.Report.VisualConstructor.FieldEventHandlers.PreviewBlock',
                'action' => 'reloadWidgetPreview'
            ));
        }
 
        $this->addFormElement($reportHandlerSelectContainer->end());
 
        $selectListContainer = new Div();
        $selectListContainer->setKey('report_configuration_select_list');
        $selectListContainer->addClass('report-configuration-row');
        $selectListContainer->addClass('report-configuration-row-list');
 
        $this->addFormElement($selectListContainer->start());
        $this->addFormElement($whatWillCalculateField);
        $this->addFormElement($selectListContainer->end());
        $this->addFormElement($fieldListContainer->end());
        $this->addFormElement($mainContainer->end());
    }
 
    public function getCalculateField()
    {
        $whatWillCalculate = new DropDown('calculate');
        $whatWillCalculate->setLabel(Loc::getMessage('BASE_REPORT_HANDLER_WHAT_WILL_CALCULATE'));
        $whatWillCalculate->addOptions($this->getWhatWillCalculateOptions());
 
        return $whatWillCalculate;
    }
 
    public function getGroupingField(DropDown $whatWillCalculateField)
    {
        $groupingField = new CustomDropDown('groupingBy');
        $groupingField->setLabel(Loc::getMessage('BASE_REPORT_HANDLER_GROUPING'));
        $groupingField->addOptions($this->getGroupByOptions());
        $whatWillCalculateField->addJsEventListener($groupingField, $groupingField::JS_EVENT_ON_CHANGE, array(
            'class' => 'BX.Report.VisualConstructor.FieldEventHandlers.WhatWillCalculate',
            'action' => 'reloadCompatibleCalculatedTypes',
        ));
        $whatWillCalculateField->addAssets(array(
            'js' => array('/bitrix/js/report/js/visualconstructor/fields/whatwillcalculate.js')
        ));
 
        return $groupingField;
    }
 
    protected function getGroupByOptions()
    {
        return array();
    }
 
    public function getFormElements()
    {
        $pseudoReportId = '_pseudo' . randString(4);
        $result = array();
        foreach ($this->formElementsList as $key => $element)
        {
            $viewModesWhereFieldAvailable = $element->getCompatibleViewTypes();
            if ($viewModesWhereFieldAvailable != null)
            {
                $viewKey = $this->getView()->getKey();
                $viewProvider = new ViewProvider();
                $viewProvider->addFilter('primary', $viewKey);
                $viewProvider->addFilter('dataType', $viewModesWhereFieldAvailable);
                $views = $viewProvider->execute()->getResults();
                if (!empty($views))
                {
                    $result[$key] = $element;
                }
            }
            else
            {
                $result[$key] = $element;
            }
            if ($element instanceof BaseValuable)
            {
                $element->setName($this->getNameForFormElement($element, $pseudoReportId));
            }
        }
 
        return $result;
    }
 
 
    protected function getNameForFormElement(BaseValuable $element, $pseudoReportId = '')
    {
        $name = '';
        if ($this->getWidgetHandler() && $this->getReport())
        {
            $name = 'widget[' .
                $this->getWidgetHandler()->getWidget()->getGId() .
                '][reports][' .
                $this->getReport()->getGId() .
                ']';
        }
        elseif(!$this->getReport())
        {
            $name =  'widget[' .
                $this->getWidgetHandler()->getWidget()->getGId() .
                '][reports][' .
                $pseudoReportId .
                ']';
        }
 
        $name .= parent::getNameForFormElement($element);
        return $name;
    }
 
    public function getTitle()
    {
        return $this->title;
    }
 
    public function setTitle($title)
    {
        $this->title = $title;
    }
 
    public function getWeight()
    {
        return $this->weight;
    }
 
    public function setWeight($weight)
    {
        $this->weight = $weight;
    }
 
    public function getReport()
    {
        return $this->report;
    }
 
    public function setReport($report)
    {
 
        $this->report = $report;
    }
 
    public function getCalculatedData()
    {
        return $this->calculatedData;
    }
 
    public function setCalculatedData($calculatedData)
    {
        $this->calculatedData = $calculatedData;
    }
 
    public function fillReport(Report $report)
    {
        $viewHandler = $this->getView();
        if ($viewHandler)
        {
            $this->setView($viewHandler);
        }
        $this->setReport($report);
        $this->setConfigurations($report->getConfigurations());
        $this->getCollectedFormElements();
        $this->fillFormElementsValues();
    }
 
    private function fillFormElementsValues()
    {
        $formElements = $this->getFormElements();
        $configurations = $this->getConfigurations();
        if (!empty($configurations))
        {
            foreach ($configurations as $configuration)
            {
                if (isset($formElements[$configuration->getKey()]) && ($formElements[$configuration->getKey()] instanceof BaseValuable))
                {
                    $formElements[$configuration->getKey()]->setValue($configuration->getValue());
                }
            }
        }
    }
 
    public function getCategoryKey()
    {
        return $this->categoryKey;
    }
 
    protected function setCategoryKey($categoryKey)
    {
        $this->categoryKey = $categoryKey;
    }
 
    public function getUnitKey()
    {
        return $this->unitKey;
    }
 
    protected function setUnitKey($unitKey)
    {
        $this->unitKey = $unitKey;
    }
 
    private function getReportHandlerCategoryField()
    {
        $selectField = new CustomDropDown('reportCategory');
        $selectField->setLabel(Loc::getMessage('SELECT_REPORT_HANDLER_CATEGORY'));
        $categories = new CategoryProvider();
        $categories->addFilter('parent_keys', 'main');
        $categories->addRelation('children');
        $categories->addRelation('parent');
        $categories  = $categories->execute()->getResults();
        $options = Category::getOptionsTree($categories);
        $selectField->addOptions($options);
 
        $selectField->setValue($this->getCategoryKey());
        return $selectField;
    }
 
    private function getReportHandlerSelectField($categoryKey = '__')
    {
        $selectField = new CustomDropDown('reportHandler');
        $selectField->addDataAttribute('field-type', 'report-handler-class');
        $selectField->setLabel(Loc::getMessage('SELECT_DATA_PROVIDER'));
        $selectField->addJsEventListener($selectField, $selectField::JS_EVENT_ON_CHANGE, array(
            'class' => 'BX.Report.VisualConstructor.FieldEventHandlers.ReportHandlerSelect',
            'action' => 'reportHandlerSelected',
        ));
        $selectField->addAssets(array(
            'js' => array('/bitrix/js/report/js/visualconstructor/fields/reporthandlerselect.js')
        ));
 
        $reports = new ReportProvider();
        $reports->addFilter('dataType', $this->getView()->getCompatibleDataType());
 
        if (!empty($categoryKey) && $categoryKey !== '__')
        {
            $reports->addFilter('categories', array($categoryKey));
        }
 
        $reports->execute();
 
        $reportHandlers = $reports->getResults();
        foreach ($reportHandlers as $report)
        {
            $selectField->addOption($report::getClassName(), $report->getTitle());
        }
 
        $selectField->setDefaultValue($this::getClassName());
 
        return $selectField;
    }
 
    public function getReportImplementedDataTypes()
    {
        $dataTypeMap = Common::$reportImplementationTypesMap;
        $class = get_class($this);
        $implementedInterfaceList = class_implements($class);
        $implementedInterfaceList = array_values($implementedInterfaceList);
        $result = array();
        foreach ($dataTypeMap as $reportTypeKey => $settings)
        {
            if (in_array($settings['interface'], $implementedInterfaceList))
            {
                $result[] = $reportTypeKey;
            }
        }
        return $result;
    }
 
    public function getWidgetHandler()
    {
        if ($this->getReport()->getWidget())
        {
            return $this->getReport()->getWidget()->getWidgetHandler();
        }
        elseif ($this->widgetHandler)
        {
            return $this->widgetHandler;
        }
        else
        {
            return null;
        }
    }
 
    public function setWidgetHandler(BaseWidget $widgetHandler)
    {
        $this->widgetHandler = $widgetHandler;
    }
 
    public function __clone()
    {
        foreach ($this->configurations as $key => $configuration)
        {
            $this->configurations[$key] = clone $configuration;
        }
 
        foreach ($this->formElementsList as $key => $formElement)
        {
            $this->formElementsList[$key] = clone $formElement;
        }
    }
 
    public function getWhatWillCalculateOptions($groupingValue = null)
    {
        return array();
    }
 
    public function isEnabled()
    {
        return true;
    }
}