www/manager6/StateProvider.js

   1 /* This state provider keeps part of the state inside
   2  * the browser history.
   3  *
   4  * We compress (shorten) url using dictionary based compression
   5  * i.e. use column separated list instead of url encoded hash:
   6  * #v\d*       version/format
   7  * :=          indicates string values
   8  * :\d+        lookup value in dictionary hash
   9  * #v1:=value1:5:=value2:=value3:...
  10 */
  11
  12 Ext.define('PVE.StateProvider', {
  13     extend: 'Ext.state.LocalStorageProvider',
  14
  15     // private
  16     setHV: function(name, newvalue, fireEvents) {
  17         let me = this;
  18
  19         let changes = false;
  20         let oldtext = Ext.encode(me.UIState[name]);
  21         let newtext = Ext.encode(newvalue);
  22         if (newtext !== oldtext) {
  23             changes = true;
  24             me.UIState[name] = newvalue;
  25             if (fireEvents) {
  26                 me.fireEvent("statechange", me, name, { value: newvalue });
  27             }
  28         }
  29         return changes;
  30     },
  31
  32     // private
  33     hslist: [
  34         // order is important for notifications
  35         // [ name, default ]
  36         ['view', 'server'],
  37         ['rid', 'root'],
  38         ['ltab', 'tasks'],
  39         ['nodetab', ''],
  40         ['storagetab', ''],
  41         ['sdntab', ''],
  42         ['pooltab', ''],
  43         ['kvmtab', ''],
  44         ['lxctab', ''],
  45         ['dctab', ''],
  46     ],
  47
  48     hprefix: 'v1',
  49
  50     compDict: {
  51         sdn: 53,
  52         cloudinit: 52,
  53         replication: 51,
  54         system: 50,
  55         monitor: 49,
  56         'ha-fencing': 48,
  57         'ha-groups': 47,
  58         'ha-resources': 46,
  59         'ceph-log': 45,
  60         'ceph-crushmap': 44,
  61         'ceph-pools': 43,
  62         'ceph-osdtree': 42,
  63         'ceph-disklist': 41,
  64         'ceph-monlist': 40,
  65         'ceph-config': 39,
  66         ceph: 38,
  67         'firewall-fwlog': 37,
  68         'firewall-options': 36,
  69         'firewall-ipset': 35,
  70         'firewall-aliases': 34,
  71         'firewall-sg': 33,
  72         firewall: 32,
  73         apt: 31,
  74         members: 30,
  75         snapshot: 29,
  76         ha: 28,
  77         support: 27,
  78         pools: 26,
  79         syslog: 25,
  80         ubc: 24,
  81         initlog: 23,
  82         openvz: 22,
  83         backup: 21,
  84         resources: 20,
  85         content: 19,
  86         root: 18,
  87         domains: 17,
  88         roles: 16,
  89         groups: 15,
  90         users: 14,
  91         time: 13,
  92         dns: 12,
  93         network: 11,
  94         services: 10,
  95         options: 9,
  96         console: 8,
  97         hardware: 7,
  98         permissions: 6,
  99         summary: 5,
 100         tasks: 4,
 101         clog: 3,
 102         storage: 2,
 103         folder: 1,
 104         server: 0,
 105     },
 106
 107     decodeHToken: function(token) {
 108         let me = this;
 109
 110         let state = {};
 111         if (!token) {
 112             me.hslist.forEach(([k, v]) => { state[k] = v; });
 113             return state;
 114         }
 115
 116         let [prefix, ...items] = token.split(':');
 117
 118         if (prefix !== me.hprefix) {
 119             return me.decodeHToken();
 120         }
 121
 122         Ext.Array.each(me.hslist, function(rec) {
 123             let value = items.shift();
 124             if (value) {
 125                 if (value[0] === '=') {
 126                     value = decodeURIComponent(value.slice(1));
 127                 } else {
 128                     for (const [key, hash] of Object.entries(me.compDict)) {
 129                         if (value === hash) {
 130                             value = key;
 131                             break;
 132                         }
 133                     }
 134                 }
 135             }
 136             state[rec[0]] = value;
 137         });
 138
 139         return state;
 140     },
 141
 142     encodeHToken: function(state) {
 143         let me = this;
 144
 145         let ctoken = me.hprefix;
 146         Ext.Array.each(me.hslist, function(rec) {
 147             let value = state[rec[0]];
 148             if (!Ext.isDefined(value)) {
 149                 value = rec[1];
 150             }
 151             value = encodeURIComponent(value);
 152             if (!value) {
 153                 ctoken += ':';
 154             } else if (Ext.isDefined(me.compDict[value])) {
 155                 ctoken += ":" + me.compDict[value];
 156             } else {
 157                 ctoken += ":=" + value;
 158             }
 159         });
 160
 161         return ctoken;
 162     },
 163
 164     constructor: function(config) {
 165         let me = this;
 166
 167         me.callParent([config]);
 168
 169         me.UIState = me.decodeHToken(); // set default
 170
 171         let history_change_cb = function(token) {
 172             if (!token) {
 173                 Ext.History.back();
 174                 return;
 175             }
 176
 177             let newstate = me.decodeHToken(token);
 178             Ext.Array.each(me.hslist, function(rec) {
 179                 if (typeof newstate[rec[0]] === "undefined") {
 180                     return;
 181                 }
 182                 me.setHV(rec[0], newstate[rec[0]], true);
 183             });
 184         };
 185
 186         let start_token = Ext.History.getToken();
 187         if (start_token) {
 188             history_change_cb(start_token);
 189         } else {
 190             let htext = me.encodeHToken(me.UIState);
 191             Ext.History.add(htext);
 192         }
 193
 194         Ext.History.on('change', history_change_cb);
 195     },
 196
 197     get: function(name, defaultValue) {
 198         let me = this;
 199
 200         let data;
 201         if (typeof me.UIState[name] !== "undefined") {
 202             data = { value: me.UIState[name] };
 203         } else {
 204             data = me.callParent(arguments);
 205             if (!data && name === 'GuiCap') {
 206                 data = {
 207                     vms: {},
 208                     storage: {},
 209                     access: {},
 210                     nodes: {},
 211                     dc: {},
 212                     sdn: {},
 213                 };
 214             }
 215         }
 216         return data;
 217     },
 218
 219     clear: function(name) {
 220         let me = this;
 221
 222         if (typeof me.UIState[name] !== "undefined") {
 223             me.UIState[name] = null;
 224         }
 225         me.callParent(arguments);
 226     },
 227
 228     set: function(name, value, fireevent) {
 229         let me = this;
 230
 231         if (typeof me.UIState[name] !== "undefined") {
 232             var newvalue = value ? value.value : null;
 233             if (me.setHV(name, newvalue, fireevent)) {
 234                 let htext = me.encodeHToken(me.UIState);
 235                 Ext.History.add(htext);
 236             }
 237         } else {
 238             me.callParent(arguments);
 239         }
 240     },
 241 });