yvan-ext/src/controls/stores.js

import _ from 'lodash'
import {lookupScope, lookupFn} from "../lib/lib";
import {serverInvokeUrlTransform, apiConvert} from "../lib/config";
import {calcObjectFlat} from '../lib/systemLib'

/**
 * 构建一个 grid 支持的 dataSource
 */
export function gridInvokeBuild(scope, grid, config, dataSource, reloadParams = {}) {
    const me = grid
    const params = calcObjectFlat(scope.viewModel.data, dataSource.params)
    let storeOption = {}

    if (dataSource.method === 'invoke') {
        // 默认支持 gridInvoke
        storeOption = {
            remoteSort: config.remoteSort,
            remoteFilter: config.remoteFilter,
            autoLoad: true,
            proxy: {
                type: 'jsonAjax',
                $owner: me,
                url: serverInvokeUrlTransform(dataSource.url),
                extraParams: _.defaultsDeep({}, reloadParams, params),
                reader: {
                    type: 'json',
                    rootProperty: 'data',
                    totalProperty: 'pagination.total',
                    successProperty: 'success',
                    messageProperty: 'msg',
                    transform: function (data) {
                        if (grid.dataTransform) {
                            if (typeof grid.dataTransform === 'string') {
                                grid.dataTransform = lookupFn(lookupScope(grid), grid.dataTransform)
                            }

                            return grid.dataTransform.call(scope, grid, data)
                        }
                        return data
                    }
                }
            },
            listeners: {
                load: function (store, records, successful, operation) {
                    me.fireEvent('dataLoadComplete', me, successful, records);
                }
            }
        }

    } else if (apiConvert) {
        // 外部扩展的 apiConvert
        storeOption = apiConvert.gridInvokeBuild(scope, grid, config, dataSource, params, reloadParams)

    } else {
        throw new TypeError("不支持的 API 请求方式")
    }

    me.setStore(new Ext.data.Store(storeOption))
}

export default function () {

    Ext.define('Yvan.JsonAjaxProxy', {
        extend: 'Ext.data.proxy.Ajax',
        alias: 'proxy.jsonAjax',
        actionMethods: {
            create: "POST",
            read: "POST",
            update: "POST",
            destroy: "POST"
        },
        buildRequest: function (operation) {
            // 参考源码 ext-all-debug.js:71468 method:buildRequest
            const me = this
            const {$owner} = me // 在 grid.initComponent 中赋值 $owner
            const scope = lookupScope($owner)

            const gridParam = me.getParams(operation)
            const customParam = {}

            // 提取 srot 元素
            if (gridParam.sort) {
                const sort = JSON.parse(gridParam.sort)
                // 字符串 [{"property":"BRANCHID","direction":"ASC"}]
                // 转换为对象 [{colId: "BRANCHID", sort: "asc"}]
                customParam.sortModel = []
                _.forEach(sort, s => {
                    customParam.sortModel.push({
                        colId: s.property,
                        sort: _.toLower(s.direction)
                    })
                })
                delete gridParam.sort
            }

            // 提取筛选元素
            if (gridParam.filter) {
                const filter = JSON.parse(gridParam.filter)
                // "[{"operator":"like","value":"1","property":"id"}]"
                // 转换为 filterModel: {BRANCHID: {filterType: "text", type: "contains", filter: "12"}}
                customParam.filterModel = {}
                _.forEach(filter, s => {
                    const newFilterItem = {}
                    if (s.operator === 'like') {
                        newFilterItem.filterType = 'text';
                        newFilterItem.type = 'contains';
                        newFilterItem.filter = s.value;
                    } else {
                        // 无法识别的筛选类型
                        debugger
                    }
                    customParam.filterModel[s.property] = newFilterItem
                })
                delete gridParam.filter
            }

            // 被 grid.constructor 作为方法存在
            const extraParams = _.cloneDeep(me.getExtraParams())
            const params = _.defaultsDeep(gridParam, extraParams)

            // var request = this.superclass.buildRequest.apply(this, arguments);
            let request = new Ext.data.Request({
                params: {},
                action: operation.getAction(),
                records: operation.getRecords(),
                url: me.buildUrl(),
                jsonData: {
                    args: [
                        params
                    ],
                    ...customParam
                },
                proxy: me
            });

            operation.setRequest(request);
            return request;
        },
        afterRequest: function (req, res) {
            // Extend.afterExtRequest(req, res)
        }
    });


    Ext.define('Ext.ux.data.MyReader', {
        extend: 'Ext.data.reader.Json',
        xtype: 'yvgridreader',

        useSimpleAccessors: false,

        // 重写解析 data 的方法
        // extractData: function (data) {
        //     // callParent 要换写成 this.superclass.XXX.call(this, ...)
        //     // return me.callParent([data]);
        //
        //     if (this.metaData && Ext.isArray(this.metaData.fields)) {
        //         // data : [][] 换写成数组
        //         data = _.map(data, row => {
        //             const newRow = {}
        //             for (var i = 0; i < this.metaData.fields.length; i++) {
        //                 newRow[this.metaData.fields[i]] = row[i]
        //             }
        //             return newRow
        //         })
        //     }
        //
        //     const rr = this.superclass.extractData.call(this, data);
        //     return rr;
        // }
    });
}