O componente Magento Grid não está sendo classificado corretamente

Eu configurei um componente de grade no Magento - e o comportamento de classificação parece quebrado. Onde posso depurar isso no nível do javascript e / ou mais alguém tem alguma idéia de por que isso pode estar acontecendo?

Se eu classificar a grade uma vez, uma solicitação ajax será feita e tudo será classificado corretamente.

No entanto, o segundo tipo, sem uma solicitação de ajax, renderiza a grade com os mesmos IDs.

O comportamento não se repete nas redes principais do Magento, por isso tenho certeza de que isso é algo que estou fazendo. Eu apenas não conheço o sistema de componentes da interface do usuário o suficiente para saber por onde começar a depurar isso.

Tudo bem, eu não posso fingir entender o porquê ainda, mas o problema foi o dataargumento do meu dataProviderargumento.

<!-- ... -->
<argument name="dataProvider" xsi:type="configurableObject">
    <!-- ... --->
    <argument name="data" xsi:type="array">
        <item name="config" xsi:type="array">
            <item name="update_url" xsi:type="url" path="mui/index/render"/>
        </item>
    </argument>
    <!-- ... -->
</argument>
<!-- ... -->

Quando comparei isso a algumas das redes principais, o dataargumento estava ausente de um storageConfignó, com um indexFieldsubnó com a chave primária do meu modelo.

<argument name="data" xsi:type="array">
    <item name="config" xsi:type="array">
        <item name="update_url" xsi:type="url" path="mui/index/render"/>
        <item name="storageConfig" xsi:type="array">
            <item name="indexField" xsi:type="string">pulsestorm_commercebug_log_id</item>
        </item>                    

    </item>                          
</argument>

Quando adicionei esses nós, a funcionalidade de classificação foi restaurada.

TL; DR

Este é realmente um problema interessante.

Aqui está como eu entendi o sistema, mas posso não estar 100% certo.

Como você viu, clicar na coluna do cabeçalho gera uma solicitação AJAX para a seguinte rota: /admin_key/mui/index/rendercom os seguintes parâmetros:

• filtros [espaço reservado]
• isAjax
• namespace
• paginação [atual]
• paginação [tamanho da página]
• procurar
• classificação [direção]
• classificação [campo]

O último é o campo no qual você está classificando sua grade.

Esta rota é declarada por padrão em app/code/Magento/Ui/view/base/ui_component/etc/definition.xml:

<insertListing class="Magento\Ui\Component\Container">
    <argument name="data" xsi:type="array">
        <item name="config" xsi:type="array">
            <item name="component" xsi:type="string">Magento_Ui/js/form/components/insert-listing</item>
            <item name="update_url" xsi:type="url" path="mui/index/render"/>
            <item name="render_url" xsi:type="url" path="mui/index/render"/>
            <item name="autoRender" xsi:type="boolean">false</item>
            <item name="dataLinks" xsi:type="array">
                <item name="imports" xsi:type="boolean">true</item>
                <item name="exports" xsi:type="boolean">false</item>
            </item>
            <item name="realTimeLink" xsi:type="boolean">true</item>
        </item>
    </argument>
</insertListing>

Mas em uma listagem ui_component XML, também é declarado:

        <argument name="data" xsi:type="array">
            <item name="config" xsi:type="array">
                <item name="component" xsi:type="string">Magento_Ui/js/grid/provider</item>
                <item name="update_url" xsi:type="url" path="mui/index/render"/>
                <item name="storageConfig" xsi:type="array">
                    <item name="indexField" xsi:type="string">page_id</item>
                </item>
            </item>
        </argument>

Essa rota é tratada com app/code/Magento/Ui/Controller/Adminhtml/Index/Render.phpbase no parâmetro namespace (que normalmente é o nome do seu componente de interface do usuário)

public function execute()
{
    if ($this->_request->getParam('namespace') === null) {
        $this->_redirect('admin/noroute');
        return;
    }

    $component = $this->factory->create($this->_request->getParam('namespace'));
    $this->prepareComponent($component);
    $this->_response->appendBody((string) $component->render());
}

Onde o prepareComponentmétodo é recursivo nos componentes filhos:

protected function prepareComponent(UiComponentInterface $component)
{
    foreach ($component->getChildComponents() as $child) {
        $this->prepareComponent($child);
    }
    $component->prepare();
}

Quando o componente da coluna é preparado, a classificação da coluna é tratada por app/code/Magento/Ui/Component/Listing/Columns/Column.php:

public function prepare()
{
    $this->addFieldToSelect();

    $dataType = $this->getData('config/dataType');
    if ($dataType) {
        $this->wrappedComponent = $this->uiComponentFactory->create(
            $this->getName(),
            $dataType,
            array_merge(['context' => $this->getContext()], (array) $this->getData())
        );
        $this->wrappedComponent->prepare();
        $wrappedComponentConfig = $this->getJsConfig($this->wrappedComponent);
        // Merge JS configuration with wrapped component configuration
        $jsConfig = array_replace_recursive($wrappedComponentConfig, $this->getJsConfig($this));
        $this->setData('js_config', $jsConfig);

        $this->setData(
            'config',
            array_replace_recursive(
                (array)$this->wrappedComponent->getData('config'),
                (array)$this->getData('config')
            )
        );
    }

    $this->applySorting();

    parent::prepare();
}

Onde o applySorting()método se baseia no parâmetro de classificação e simplesmente adiciona a ordem ao provedor de dados:

protected function applySorting()
{
    $sorting = $this->getContext()->getRequestParam('sorting');
    $isSortable = $this->getData('config/sortable');
    if ($isSortable !== false
        && !empty($sorting['field'])
        && !empty($sorting['direction'])
        && $sorting['field'] === $this->getName()
    ) {
        $this->getContext()->getDataProvider()->addOrder(
            $this->getName(),
            strtoupper($sorting['direction'])
        );
    }
}

Depois que cada componente é preparado, a classe de ação renderiza o componente (novamente recursivamente) para a resposta:

$this->_response->appendBody((string) $component->render());

Acho que essas são as etapas importantes do PHP que acontecem durante a classificação.

Agora para o JS, os URLs de renderização e atualização (declarados definition.xmlacima) são atribuídos ao elemento em app/code/Magento/Ui/view/base/web/js/form/components/insert.js:

return Element.extend({
    defaults: {
        content: '',
        template: 'ui/form/insert',
        showSpinner: true,
        loading: false,
        autoRender: true,
        visible: true,
        contentSelector: '${$.name}',
        externalData: [],
        params: {
            namespace: '${ $.ns }'
        },
        renderSettings: {
            url: '${ $.render_url }',
            dataType: 'html'
        },
        updateSettings: {
            url: '${ $.update_url }',
            dataType: 'json'
        },
        imports: {},
        exports: {},
        listens: {},
        links: {
            value: '${ $.provider }:${ $.dataScope}'
        },
        modules: {
            externalSource: '${ $.externalProvider }'
        }
    }

Ainda neste arquivo, há um requestDatamétodo usado para recuperar os dados AJAX:

    requestData: function (params, ajaxSettings) {
        var query = utils.copy(params);

        ajaxSettings = _.extend({
            url: this['update_url'],
            method: 'GET',
            data: query,
            dataType: 'json'
        }, ajaxSettings);

        this.loading(true);

        return $.ajax(ajaxSettings);
    }

Você pode ver que esse método é chamado quando o render()método é chamado:

        $.async({
            component: this.name,
            ctx: '.' + this.contentSelector
        }, function (el) {
            self.contentEl = $(el);
            self.startRender = true;
            params = _.extend({}, self.params, params || {});
            request = self.requestData(params, self.renderSettings);
            request
                .done(self.onRender)
                .fail(self.onError);
        });

Feito isso, um método de retorno de chamada é chamado para aplicar os dados. É onRender():

    onRender: function (data) {
        this.loading(false);
        this.set('content', data);
        this.isRendered = true;
        this.startRender = false;
    }

Eu acho que é aí que o novo conteúdo está sendo aplicado.