extjs/packages/ux/src/ajax/DataSimlet.js

   1 /**
   2  * This base class is used to handle data preparation (e.g., sorting, filtering and
   3  * group summary).
   4  */
   5 Ext.define('Ext.ux.ajax.DataSimlet', function () {
   6
   7     function makeSortFn (def, cmp) {
   8         var order = def.direction,
   9             sign = (order && order.toUpperCase() === 'DESC') ? -1 : 1;
  10
  11         return function (leftRec, rightRec) {
  12             var lhs = leftRec[def.property],
  13                 rhs = rightRec[def.property],
  14                 c = (lhs < rhs) ? -1 : ((rhs < lhs) ? 1 : 0);
  15
  16             if (c || !cmp) {
  17                 return c * sign;
  18             }
  19
  20             return cmp(leftRec, rightRec);
  21         };
  22     }
  23
  24     function makeSortFns (defs, cmp) {
  25         for (var sortFn = cmp, i = defs && defs.length; i; ) {
  26             sortFn = makeSortFn(defs[--i], sortFn);
  27         }
  28         return sortFn;
  29     }
  30
  31     return {
  32         extend: 'Ext.ux.ajax.Simlet',
  33
  34         buildNodes: function (node, path) {
  35             var me = this,
  36                 nodeData = {
  37                     data: []
  38                 },
  39                 len = node.length,
  40                 children, i, child, name;
  41
  42             me.nodes[path] = nodeData;
  43
  44             for (i = 0; i < len; ++i) {
  45                 nodeData.data.push(child = node[i]);
  46                 name = child.text || child.title;
  47
  48                 child.id = path ? path + '/' + name : name;
  49                 children = child.children;
  50
  51                 if (!(child.leaf = !children)) {
  52                     delete child.children;
  53
  54                     me.buildNodes(children, child.id);
  55                 }
  56             }
  57         },
  58
  59         deleteRecord : function(pos) {
  60             if(this.data && typeof this.data !== 'function') {
  61                 Ext.Array.removeAt(this.data,pos);
  62             }
  63         },
  64
  65         fixTree: function (ctx, tree) {
  66             var me = this,
  67                 node = ctx.params.node,
  68                 nodes;
  69
  70             if (!(nodes = me.nodes)) {
  71                 me.nodes = nodes = {};
  72                 me.buildNodes(tree, '');
  73             }
  74
  75             node = nodes[node];
  76             if (node) {
  77                 if (me.node) {
  78                     me.node.sortedData = me.sortedData;
  79                     me.node.currentOrder = me.currentOrder;
  80                 }
  81
  82                 me.node = node;
  83                 me.data = node.data;
  84                 me.sortedData = node.sortedData;
  85                 me.currentOrder = node.currentOrder;
  86             } else {
  87                 me.data = null;
  88             }
  89         },
  90
  91         getData: function (ctx) {
  92             var me = this,
  93                 params = ctx.params,
  94                 order = (params.filter || '') + (params.group || '') + '-' + (params.sort || '') + '-' + (params.dir || ''),
  95                 tree = me.tree,
  96                 dynamicData,
  97                 data, fields, sortFn;
  98
  99             if (tree) {
 100                 me.fixTree(ctx, tree);
 101             }
 102
 103             data = me.data;
 104             if (typeof data === 'function') {
 105                 dynamicData = true;
 106                 data = data.call(this, ctx);
 107             }
 108
 109             // If order is '--' then it means we had no order passed, due to the string concat above
 110             if (!data || order === '--') {
 111                 return data || [];
 112             }
 113
 114             if (!dynamicData && order == me.currentOrder) {
 115                 return me.sortedData;
 116             }
 117
 118             ctx.filterSpec = params.filter && Ext.decode(params.filter);
 119             ctx.groupSpec = params.group && Ext.decode(params.group);
 120
 121             fields = params.sort;
 122             if (params.dir) {
 123                 fields = [{ direction: params.dir, property: fields }];
 124             } else {
 125                 fields = Ext.decode(params.sort);
 126             }
 127
 128             if (ctx.filterSpec) {
 129                 var filters = new Ext.util.FilterCollection();
 130                 filters.add(this.processFilters(ctx.filterSpec));
 131                 data = Ext.Array.filter(data, filters.getFilterFn());
 132             }
 133
 134             sortFn = makeSortFns((ctx.sortSpec = fields));
 135             if (ctx.groupSpec) {
 136                 sortFn = makeSortFns([ctx.groupSpec], sortFn);
 137             }
 138
 139             // If a straight Ajax request, data may not be an array.
 140             // If an Array, preserve 'physical' order of raw data...
 141             data = Ext.isArray(data) ? data.slice(0) : data;
 142             if (sortFn) {
 143                 Ext.Array.sort(data, sortFn);
 144             }
 145
 146             me.sortedData = data;
 147             me.currentOrder = order;
 148
 149             return data;
 150         },
 151
 152         processFilters: Ext.identityFn,
 153
 154         getPage: function (ctx, data) {
 155             var ret = data,
 156                 length = data.length,
 157                 start = ctx.params.start || 0,
 158                 end = ctx.params.limit ? Math.min(length, start + ctx.params.limit) : length;
 159
 160             if (start || end < length) {
 161                 ret = ret.slice(start, end);
 162             }
 163
 164             return ret;
 165         },
 166
 167         getGroupSummary: function (groupField, rows, ctx) {
 168             return rows[0];
 169         },
 170
 171         getSummary: function (ctx, data, page) {
 172             var me = this,
 173                 groupField = ctx.groupSpec.property,
 174                 accum,
 175                 todo = {},
 176                 summary = [],
 177                 fieldValue,
 178                 lastFieldValue;
 179
 180             Ext.each(page, function (rec) {
 181                 fieldValue = rec[groupField];
 182                 todo[fieldValue] = true;
 183             });
 184
 185             function flush () {
 186                 if (accum) {
 187                     summary.push(me.getGroupSummary(groupField, accum, ctx));
 188                     accum = null;
 189                 }
 190             }
 191
 192             // data is ordered primarily by the groupField, so one pass can pick up all
 193             // the summaries one at a time.
 194             Ext.each(data, function (rec) {
 195                 fieldValue = rec[groupField];
 196
 197                 if (lastFieldValue !== fieldValue) {
 198                     flush();
 199                     lastFieldValue = fieldValue;
 200                 }
 201
 202                 if (!todo[fieldValue]) {
 203                     // if we have even 1 summary, we have summarized all that we need
 204                     // (again because data and page are ordered by groupField)
 205                     return !summary.length;
 206                 }
 207
 208                 if (accum) {
 209                     accum.push(rec);
 210                 } else {
 211                     accum = [rec];
 212                 }
 213
 214                 return true;
 215             });
 216
 217             flush(); // make sure that last pesky summary goes...
 218
 219             return summary;
 220         }
 221     };
 222 }());