js/RuleInfo.js

   1 Ext.define('PMG.RuleInfo', {
   2     extend: 'Ext.panel.Panel',
   3     xtype: 'pmgRuleInfo',
   4
   5     controller: {
   6         xclass: 'Ext.app.ViewController',
   7
   8         setBaseUrl: function(baseurl) {
   9             var me = this;
  10             me.getViewModel().set('baseurl', baseurl);
  11             me.reload();
  12         },
  13
  14         reload: function() {
  15             var me = this;
  16             var viewmodel = me.getViewModel();
  17             var baseurl = viewmodel.get('baseurl');
  18
  19             if (!baseurl) {
  20                 me.setRuleInfo(undefined);
  21                 return;
  22             }
  23
  24             Proxmox.Utils.API2Request({
  25                 url: baseurl + "/config",
  26                 method: 'GET',
  27                 success: function(response, opts) {
  28                     me.setRuleInfo(response.result.data);
  29                 },
  30                 failure: function(response, opts) {
  31                     Ext.Msg.alert(gettext('Error'), response.htmlStatus);
  32                 },
  33             });
  34         },
  35
  36         removeObjectGroup: function(rec) {
  37             var me = this;
  38             Ext.Msg.confirm(
  39                 gettext('Confirm'),
  40                 Ext.String.format(
  41                     gettext('Are you sure you want to remove entry {0}'),
  42                     "'" + rec.data.name + "'"),
  43                 function(button) {
  44                     if (button === 'yes') {
  45                         Proxmox.Utils.API2Request({
  46                             url: me.getViewModel().get('baseurl') + '/' + rec.data.oclass + '/'+ rec.data.typeid,
  47                             method: 'DELETE',
  48                             waitMsgTarget: me.getView(),
  49                             callback: function() {
  50                                 me.reload();
  51                             },
  52                             failure: function(response, opts) {
  53                                 Ext.Msg.alert(gettext('Error'), response.htmlStatus);
  54                             },
  55                         });
  56                     }
  57                 },
  58             );
  59         },
  60
  61         addObjectGroup: function(type, record) {
  62             var me = this;
  63             var baseurl = me.getViewModel().get('baseurl');
  64             var url = baseurl + '/' + type;
  65             var id = type === 'action'?record.data.ogroup:record.data.id;
  66             Proxmox.Utils.API2Request({
  67                 url: url,
  68                 params: { ogroup: id },
  69                 method: 'POST',
  70                 waitMsgTarget: me.getView(),
  71                 callback: function() {
  72                     me.reload();
  73                 },
  74                 failure: function(response, opts) {
  75                     Ext.Msg.alert(gettext('Error'), response.htmlStatus);
  76                 },
  77             });
  78         },
  79
  80         setRuleInfo: function(ruledata) {
  81             var me = this;
  82
  83             var viewmodel = me.getViewModel();
  84
  85             if (ruledata === undefined) {
  86                 viewmodel.set('selectedRule', null);
  87                 viewmodel.get('objects').setData([]);
  88             } else {
  89                 viewmodel.set('selectedRule', ruledata);
  90
  91                 var data = [];
  92                 Ext.Array.each(['from', 'to', 'when', 'what', 'action'], function(oc) {
  93                     var store = viewmodel.get(oc + 'objects');
  94                     if (ruledata[oc] === undefined || store === undefined) { return; }
  95
  96                     // we build a filter for the objects,
  97                     // which are already added to the rule,
  98                     // so what we only show the ones,
  99                     // which are still available
 100
 101                     var ids = Ext.Array.pluck(ruledata[oc], 'id');
 102                     // for the actions, we have a different id field
 103                     var idField = oc === 'action'?'ogroup':'id';
 104                     store.clearFilter();
 105                     store.addFilter({
 106                         filterFn: function(record) {
 107                             // FIXME
 108                             // actions have the ogroup as a string
 109                             // -> parseInt
 110                             return ids.indexOf(parseInt(record.data[idField], 10)) === -1;
 111                         },
 112                     });
 113                     store.load();
 114                     Ext.Array.each(ruledata[oc], function(og) {
 115                         data.push({ oclass: oc, name: og.name, typeid: og.id });
 116                     });
 117                 });
 118
 119                 viewmodel.get('objects').setData(data);
 120             }
 121         },
 122
 123         removeIconClick: function(gridView, rowindex, colindex, button, event, record) {
 124             var me = this;
 125             me.removeObjectGroup(record);
 126         },
 127
 128         removeDrop: function(gridView, data, overModel) {
 129             var me = this;
 130             var record = data.records[0]; // only one
 131             me.removeObjectGroup(record);
 132             return true;
 133         },
 134
 135         addIconClick: function(gridView, rowindex, colindex, button, event, record) {
 136             var me = this;
 137             me.addObjectGroup(gridView.panel.type, record);
 138             return true;
 139         },
 140
 141         addDrop: function(gridView, data, overModel) {
 142             var me = this;
 143             var record = data.records[0]; // only one
 144             me.addObjectGroup(data.view.panel.type, record);
 145             return true;
 146         },
 147
 148         control: {
 149             'grid[reference=usedobjects]': {
 150                 drop: 'addDrop',
 151             },
 152             'tabpanel[reference=availobjects] > grid': {
 153                 drop: 'removeDrop',
 154             },
 155         },
 156     },
 157
 158     viewModel: {
 159         data: {
 160             baseurl: '',
 161         },
 162
 163         stores: {
 164             objects: {
 165                 fields: ['oclass', 'name', 'typeid'],
 166                 groupField: 'oclass',
 167                 sorters: 'name',
 168             },
 169
 170             actionobjects: {
 171                 model: 'pmg-action-list',
 172                 proxy: {
 173                     type: 'proxmox',
 174                     url: "/api2/json/config/ruledb/action/objects",
 175                 },
 176                 sorters: 'name',
 177             },
 178             fromobjects: {
 179                 model: 'pmg-object-group',
 180                 proxy: {
 181                     type: 'proxmox',
 182                     url: "/api2/json/config/ruledb/who",
 183                 },
 184                 sorters: 'name',
 185             },
 186             toobjects: {
 187                 model: 'pmg-object-group',
 188                 proxy: {
 189                     type: 'proxmox',
 190                     url: "/api2/json/config/ruledb/who",
 191                 },
 192                 sorters: 'name',
 193             },
 194             whatobjects: {
 195                 model: 'pmg-object-group',
 196                 proxy: {
 197                     type: 'proxmox',
 198                     url: "/api2/json/config/ruledb/what",
 199                 },
 200                 sorters: 'name',
 201             },
 202             whenobjects: {
 203                 model: 'pmg-object-group',
 204                 proxy: {
 205                     type: 'proxmox',
 206                     url: "/api2/json/config/ruledb/when",
 207                 },
 208                 sorters: 'name',
 209             },
 210         },
 211     },
 212
 213
 214     defaults: {
 215         padding: '5 10 5 10',
 216     },
 217
 218     bodyPadding: '5 0 5 0',
 219
 220     layout: {
 221         type: 'vbox',
 222         align: 'stretch',
 223     },
 224
 225     scrollable: true,
 226
 227     items: [
 228         {
 229             xtype: 'panel',
 230             bodyPadding: '10 10 10 10',
 231             data: {
 232                 name: '',
 233             },
 234             bind: {
 235                 data: {
 236                     name: '{selectedRule.name:htmlEncode}',
 237                     priority: '{selectedRule.priority}',
 238                     active: '{selectedRule.active}',
 239                     direction: '{selectedRule.direction}',
 240                     selected: '{selectedRule}',
 241                 },
 242             },
 243             tpl: [
 244                 '<tpl if="selected">',
 245                 '<b>{name}</b><br><br>',
 246                 gettext('Priority') + ': {priority}<br>',
 247                 gettext('Direction') + ': {[PMG.Utils.format_rule_direction(values.direction)]}<br>',
 248                 gettext('Active') + ': {[Proxmox.Utils.format_boolean(values.active)]}<br>',
 249                 '<tpl else>',
 250                 gettext('Please select a rule.'),
 251                 '</tpl>',
 252             ],
 253         },
 254         {
 255             xtype: 'grid',
 256             reference: 'usedobjects',
 257             hidden: true,
 258             emptyText: gettext('No Objects'),
 259             features: [{
 260                 id: 'group',
 261                 ftype: 'grouping',
 262                 enableGroupingMenu: false,
 263                 collapsible: false,
 264                 groupHeaderTpl: [
 265                     '{[PMG.Utils.format_oclass(values.name)]}',
 266                 ],
 267             }],
 268
 269             title: gettext('Used Objects'),
 270
 271             viewConfig: {
 272                 plugins: {
 273                     ptype: 'gridviewdragdrop',
 274                     copy: true,
 275                     dragGroup: 'usedobjects',
 276                     dropGroup: 'unusedobjects',
 277
 278                     // do not show default grid dragdrop behaviour
 279                     dropZone: {
 280                         indicatorHtml: '',
 281                         indicatorCls: '',
 282                         handleNodeDrop: Ext.emptyFn,
 283                     },
 284                 },
 285             },
 286
 287             columns: [
 288                 {
 289                     header: gettext('Type'),
 290                     dataIndex: 'oclass',
 291                     hidden: true,
 292                 },
 293                 {
 294                     header: gettext('Name'),
 295                     dataIndex: 'name',
 296                     flex: 1,
 297                 },
 298                 {
 299                     text: '',
 300                     xtype: 'actioncolumn',
 301                     align: 'center',
 302                     width: 40,
 303                     items: [
 304                         {
 305                             iconCls: 'fa fa-fw fa-minus-circle',
 306                             tooltip: gettext('Remove'),
 307                             handler: 'removeIconClick',
 308                         },
 309                     ],
 310                 },
 311             ],
 312
 313             bind: {
 314                 store: '{objects}',
 315                 hidden: '{!selectedRule}',
 316             },
 317         },
 318         {
 319             xtype: 'tabpanel',
 320             title: gettext('Available Objects'),
 321             reference: 'availobjects',
 322             hidden: true,
 323             bind: {
 324                 hidden: '{!selectedRule}',
 325             },
 326             defaults: {
 327                 xtype: 'grid',
 328                 emptyText: gettext('No Objects'),
 329                 viewConfig: {
 330                     plugins: {
 331                         ptype: 'gridviewdragdrop',
 332                         dragGroup: 'unusedobjects',
 333                         dropGroup: 'usedobjects',
 334
 335                         // do not show default grid dragdrop behaviour
 336                         dropZone: {
 337                             indicatorHtml: '',
 338                             indicatorCls: '',
 339                             handleNodeDrop: Ext.emptyFn,
 340                         },
 341                     },
 342                 },
 343                 columns: [
 344                     {
 345                         header: gettext('Name'),
 346                         dataIndex: 'name',
 347                         flex: 1,
 348                     },
 349                     {
 350                         text: '',
 351                         xtype: 'actioncolumn',
 352                         align: 'center',
 353                         width: 40,
 354                         items: [
 355                             {
 356                                 iconCls: 'fa fa-fw fa-plus-circle',
 357                                 tooltip: gettext('Add'),
 358                                 handler: 'addIconClick',
 359                             },
 360                         ],
 361                     },
 362                 ],
 363             },
 364             items: [
 365                 {
 366                     title: gettext('Action'),
 367                     bind: {
 368                         store: '{actionobjects}',
 369                     },
 370                     type: 'action',
 371                     iconCls: 'fa fa-flag',
 372                 },
 373                 {
 374                     title: gettext('From'),
 375                     iconCls: 'fa fa-user-circle',
 376                     type: 'from',
 377                     bind: {
 378                         store: '{fromobjects}',
 379                     },
 380                 },
 381                 {
 382                     title: gettext('To'),
 383                     iconCls: 'fa fa-user-circle',
 384                     type: 'to',
 385                     bind: {
 386                         store: '{toobjects}',
 387                     },
 388                 },
 389                 {
 390                     title: gettext('What'),
 391                     iconCls: 'fa fa-cube',
 392                     type: 'what',
 393                     bind: {
 394                         store: '{whatobjects}',
 395                     },
 396                 },
 397                 {
 398                     title: gettext('When'),
 399                     iconCls: 'fa fa-clock-o',
 400                     type: 'when',
 401                     bind: {
 402                         store: '{whenobjects}',
 403                     },
 404                 },
 405             ],
 406         },
 407     ],
 408 });