【问题标题】:Dynamic Attributes (nested) used as Grid Columns in ExtJS在 ExtJS 中用作网格列的动态属性(嵌套)
【发布时间】:2014-12-19 00:56:25
【问题描述】:

我尝试在我的原型 mongoDB 应用程序中使用动态属性方法。

基本上这种方法只是给你这样的东西:

{
  SKU: "Y32944EW",
  type: "shoes",
  attr: [
      { "k": "manufacturer", 
        "v": "ShoesForAll",
      },
      { "k": "color", 
        "v": "blue",
      },
      { "k": "style", 
        "v": "comfort",
      },
      { "k": "size", 
        "v": "7B"
      }
  ]
}

(来源:http://askasya.com/post/dynamicattributes)。

问题在于,例如 Kendo Grid 在其数据源中不支持这种嵌套结构。

有谁知道 Sencha ExtJS 网格组件是否可以做到这一点?


更新: SKU 应该是一列,attr 数组的每个 v 应该是一列。


更新:我正在尝试在您的回答的帮助下设置一个煎茶小提琴。

https://fiddle.sencha.com/#fiddle/evc

app.js (rev2)

// create the new type
Ext.data.Types.DYNAMIC = {
    convert: function(value, record) {
       for (var i = 0, ln = value.length; i < ln; i++) {
                var item = value[i];
                record.set(item.k, item.v);
            }
            return '';
    },
    type: 'dynamic',
    sortType: Ext.data.SortTypes.none
};

// define a model
Ext.define('TestModel', {
    extend: 'Ext.data.Model',
    fields: [{name: "_id",type: "string"},
    {name: "attr",type:  Ext.data.Types.DYNAMIC}],
    idProperty: '_id'
});
// create a store with the model assigned
Ext.create('Ext.data.Store', {
    storeId: 'MyStore',
    model: 'TestModel',
    autoLoad: true,
    proxy: {
        type: 'ajax',
        url: '/data.json',
        reader: {
            idProperty: '_id',
            type: 'json',
            root: 'data'
        }
    }
});

Ext.create('Ext.grid.Panel', {
    title: 'Grid',
    store: Ext.data.StoreManager.lookup('MyStore'),
    columns: []

}); 

Ext.widget('window',{height: 200,width: 400, items: [grid ] }).show();

store.on('metachange', function(store, meta) {
    grid.reconfigure(store, meta.columns);
});

data.json (rev2)

   {
    "metaData": {
        "idProperty": "_id",
        "rootProperty": "data",
        "fields": [
            { "name": "_id","type": "string" },
            { "name": "de", "type":"string" },
            { "name": "en", "type":"string" },
            { "name": "fr", "type":"string" },
            { "name": "attr", "type":  "dynamic"}
        ],
        "columns": [
            {
                "header": "de",
                "dataIndex": "de"
            },
            {
                "header": "en",
                "dataIndex": "en"
            }
            ,
            {
                "header": "fr",
                "dataIndex": "fr"
            }
        ]
    },
 "data":     
        [
            {"_id": "MyTextId1",
                "attr":[
                    {
                        "k": "de",
                        "v": "GermanText Sample"
                    }, 
                    {
                        "k": "en",
                        "v": "English Text Sample"
                    }, 
                    {
                        "k": "fr",
                        "v": "French Text Sample"
                    },
                ]
            },
           {"_id": "MyTextId2",
               "attr":[
                   {
                       "k": "de",
                       "v": "GermanText Sample 1"
                   }, 
                   {
                       "k": "en",
                       "v": "English Text Sample 1"
                   }, 
                   {
                       "k": "fr",
                       "v": "French Text Sample1 1"
                   },
               ]
           }
        ]
}

错误信息:

 Uncaught Error: [Ext.createByAlias] Unrecognized alias: data.field.[object Object]

更新: 与 sra 的最后一次编辑中发布的 sn-p 一起使用。谢谢!

【问题讨论】:

  • 根据您的示例文档,什么结构适合 kendo-grid?
  • 我知道如何在 ExtJS 5 中执行此操作,但我需要知道您希望如何可视化您的数据结构?例如,如果它必须是平的? (即 attr 合并到与类型和 SKU 相同的级别)或者可能像这里(展开行):dev.sencha.com/extjs/5.1.0/examples/kitchensink/#customer-grid
  • 这个例子看起来很有趣。对于这个特定的用例,它可以都在同一级别。 SKU 应该是一列,attr 数组的每个 v 都应该是一列。

标签: c# json extjs


【解决方案1】:

是的,你可以。而且大部分已经内置了。让我们从基础开始

Response MetaData

服务器可以在其响应中返回元数据,除了记录数据,描述数据集本身的属性或用于重新配置阅读器。要在响应中传递元数据,您只需将 metaData 属性添加到响应数据的根。 metaData 属性可以包含任何内容,但支持由 Reader 处理的一组特定属性(如果存在):

root: the property name of the root response node containing the record data
totalProperty: property name for the total number of records in the data
successProperty: property name for the success status of the response
messageProperty: property name for an optional response message
fields: Config used to reconfigure the Model's fields before converting the response data into records

包含所有这些属性的初始阅读器配置可能如下所示(“字段”将包含在模型定义中,未显示):

reader: {
    type : 'json',
    root : 'root',
    totalProperty  : 'total',
    successProperty: 'success',
    messageProperty: 'message'
}

如果您要传递的响应对象包含与上面最初定义的属性不同的属性,则可以使用 metaData 属性即时重新配置 Reader。例如:

{
    "count": 1,
    "ok": true,
    "msg": "Users found",
    "users": [{
        "userId": 123,
        "name": "Ed Spencer",
        "email": "ed@sencha.com"
    }],
    "metaData": {
        "root": "users",
        "totalProperty": 'count',
        "successProperty": 'ok',
        "messageProperty": 'msg'
    }
}

您还可以将所需的任何其他任意数据放入读取器将忽略的元数据属性中,但可以通过读取器的 metaData 属性访问(该属性也通过代理的 metachange 事件传递给侦听器(也由存储)。然后应用程序代码可以选择任何方式处理传递的元数据。

如何使用它的一个简单示例是为绑定到网格的模型自定义字段。通过传递 fields 属性,模型将由 Reader 在内部自动更新,但除非您还更新列配置,否则该更改不会自动反映在网格中。您可以手动执行此操作,也可以简单地将标准网格列配置对象作为 metaData 属性的一部分传递,然后将其传递给网格。下面是一个非常简单的例子来说明如何实现这一点:

// response format:
{
    ...
    "metaData": {
        "fields": [
            { "name": "userId", "type": "int" },
            { "name": "name", "type": "string" },
            { "name": "birthday", "type": "date", "dateFormat": "Y-j-m" }
        ],
        "columns": [
            { "text": "User ID", "dataIndex": "userId", "width": 40 },
            { "text": "User Name", "dataIndex": "name", "flex": 1 },
            { "text": "Birthday", "dataIndex": "birthday", "flex": 1, "format": 'Y-j-m', "xtype": "datecolumn" }
        ]
    }
}

阅读器将自动读取元字段配置并根据新字段重建模型,但要处理新列配置,您需要处理应用程序代码中的元数据。这可以通过在商店或代理上处理 metachange 事件来完成,例如:

var store = Ext.create('Ext.data.Store', {
    ...
    listeners: {
        'metachange': function(store, meta) {
            myGrid.reconfigure(store, meta.columns);
        }
    }
});

这是基础知识。现在是您的数据结构的详细信息:

首先我们需要一个转换器函数来读取自定义数据

convert: function(value,record) {
    for(var i=0,ln=value.length;i<ln;i++) {
        var item = value[i];
        record.set(item.k,item.v);
    }
    return ''; let's save memory an drop it
}

我们可以发布基本字段(和列(未显示)) - 但我们不需要,因为元更改可以处理所有这些

{ name: "SKU", type:"string") }, // don't forget to mark this as the idProperty in the reader and in the model
{ name: "type", type:"string") },
{ name: "attr", type:"auto", convert: convert() }

以下所有字段和列均由服务器通过 metachange 发布

"metaData": {
    "fields": [
        { name: "SKU", type:"string") }, 
        { name: "type", type:"string") },
        { name: "attr", type:"auto", convert: convert() },
        // and the dynamic datafields
        { name: "manufacturer", type:"string" },
        { name: "style", type:"string" },
        // ... and so on
    ],
    "columns": [
        { "text": "ID", "dataIndex": "SKU", "width": 40 },
        { "text": "ID", "dataIndex": "SKU", "width": 40 },
        // and the dynamic datacolumns
        { "text": "Manufacturer", "dataIndex": "manufacturer" },
        { "text": "Style", "dataIndex": "stlye" },
        // ... and so on
    ]
}

编辑:

我建议创建您自己的阅读器,在进一步处理之前将数据转换为规范化的 JSON,或者创建您自己的 Ext.data.Types 类型。因为我认为它会更快一些,所以我建议创建自己的数据类型。您的情况的缺点是,具有此属性的字段必须始终位于动态字段之后,否则读取器将覆盖动态字段。

这是我用 4.2.3 测试过的片段

// create the new type
Ext.data.Types.DYNAMIC = {
    convert: function(value, record) {
        for (var i = 0, ln = value.length; i < ln; i++) {
            var item = value[i];
            record.data[item.k] = item.v;
        }
        return '';
    },
    type: 'dynamic',
    sortType: Ext.data.SortTypes.none
};

// define a model
Ext.define('TestModel', {
    extend: 'Ext.data.Model',
    fields: [{name: "_id",type: "string"},
    {name: "attr",type: "dynamic"}],
    idProperty: '_id'
});
// create a store with the model assigned
Ext.create('Ext.data.Store', {
    storeId: 'MyStore',
    model: 'TestModel',
    autoLoad: true,
    proxy: {
        type: 'ajax',
        url: '/data.json',
        reader: {
            idProperty: '_id',
            type: 'json',
            root: 'data'
        }
    }
});

Ext.create('Ext.grid.Panel', {
    title: 'Grid',
    store: Ext.data.StoreManager.lookup('MyStore'),
    columns: []

}); 

Ext.widget('window',{height: 200,width: 400, items: [grid ] }).show();

store.on('metachange', function(store, meta) {
    grid.reconfigure(store, meta.columns);
});

还有数据

{
    "metaData": {
        "idProperty": "_id",
        "rootProperty": "data",
        "fields": [
            { "name": "_id","type": "string" },
            { "name": "de", "type":"string" },
            { "name": "en", "type":"string" },
            { "name": "fr", "type":"string" },
            { "name": "attr", "type": "dynamic" }
        ],
        "columns": [
            {
                "header": "de",
                "dataIndex": "de"
            },
            {
                "header": "en",
                "dataIndex": "en"
            }
            ,
            {
                "header": "fr",
                "dataIndex": "fr"
            }
        ]
    },
 "data":     
        [
            {"_id": "MyTextId1",
                "attr":[
                    {
                        "k": "de",
                        "v": "GermanText Sample"
                    }, 
                    {
                        "k": "en",
                        "v": "English Text Sample"
                    }, 
                    {
                        "k": "fr",
                        "v": "French Text Sample"
                    },
                ]
            },
           {"_id": "MyTextId2",
               "attr":[
                   {
                       "k": "de",
                       "v": "GermanText Sample 1"
                   }, 
                   {
                       "k": "en",
                       "v": "English Text Sample 1"
                   }, 
                   {
                       "k": "fr",
                       "v": "French Text Sample1 1"
                   },
               ]
           }
        ]
}

编辑:

这个片段在 5.1 中经过测试并且有效

Ext.data.Types.DYNAMIC = {
    convert: function(value, record) {
        for (var i = 0, ln = value.length; i < ln; i++) {
            var item = value[i];
            record.data[item.k] = item.v;
        }
        return '';
    },
    type: 'dynamic',
    sortType: Ext.data.SortTypes.none
};


Ext.define('Ext.data.field.Dynamic', {
    extend: 'Ext.data.field.Field',

    alias: 'data.field.dynamic',

    sortType: 'none',

    isDynamicField: true,

    convert: function(value, record) {
        for (var i = 0, ln = value.length; i < ln; i++) {
            var item = value[i];
            record.data[item.k] = item.v;
        }
        return '';
    },

    getType: function() {
        return 'dynamic';
    }
});


Ext.define('TestModel', {
    extend: 'Ext.data.Model',
    fields: [{name: "_id",type: "string"},{name: "attr",type: "dynamic"}],
    idProperty: '_id'
});

var store = Ext.create('Ext.data.Store', {
    storeId: 'MyStore',
    model: 'TestModel',
    autoLoad: true,
    proxy: {
        type: 'ajax',
        url: '/qat/Content/TST/data.js',
        reader: {
            idProperty: '_id',
            type: 'json',
            rootProperty: 'data'
        }
    }
});

var grid = Ext.create('Ext.grid.Panel', {
    title: 'Grid',
    store: Ext.data.StoreManager.lookup('MyStore'),
    dockedItems: [{xtype: 'pagingtoolbar',store: Ext.data.StoreManager.lookup('MyStore'), dock: 'bottom',displayInfo: false}],
    columns: []

}); 
Ext.widget('window',{height: 200,width: 400, items: [grid ] }).show();

store.on('metachange', function(store, meta) {
    // Apply the column definitions to the Grid
    grid.reconfigure(store, meta.columns);
});

【讨论】:

  • 谢谢,它看起来很全面。正是我想要的。
  • 这和我想展示的很相似。只是为了记录,您可以创建 Ext.data.Model 并通过属性model 而不是metaData 在存储定义中指定它。 +1
  • @rzymek 好吧,这不是真正的选择,这是必须的(我把自动模型放在一边)。否则没有模型字段可以用我们的元数据字段更新;)你可以在定义模型时只保留字段,因为理论上你可以用元数据设置它们。
  • 如果我们假设“动态数据字段”的某些配置是已知的,那么我们可以创建适当的模型和备用响应大小。但是,如果我们有很多配置,那么您是对的,唯一的选择是 metaData
  • @Matthias 不要用 sencha Fiddle 尝试这个,因为它会覆盖您的自定义数据类型。在您自己的环境中尝试一下。 4.x 和 5.x 的区别仅在于 reader 根属性的定义,即 4.x 中的 root 和 5.x 中的 rootProperty
猜你喜欢
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2014-07-26
  • 1970-01-01
  • 2011-05-19
相关资源
最近更新 更多