www/manager6/panel/IPSet.js

   1 Ext.define('pve-fw-ipsets', {
   2     extend: 'Ext.data.Model',
   3     fields: [ 'name', 'comment', 'digest' ],
   4     idProperty: 'name'
   5 });
   6
   7 Ext.define('PVE.IPSetList', {
   8     extend: 'Ext.grid.Panel',
   9     alias: 'widget.pveIPSetList',
  10
  11     stateful: true,
  12     stateId: 'grid-firewall-ipsetlist',
  13
  14     ipset_panel: undefined,
  15
  16     base_url: undefined,
  17
  18     addBtn: undefined,
  19     removeBtn: undefined,
  20     editBtn: undefined,
  21
  22     initComponent: function() {
  23
  24         var me = this;
  25
  26         if (me.ipset_panel == undefined) {
  27             throw "no rule panel specified";
  28         }
  29
  30         if (me.base_url == undefined) {
  31             throw "no base_url specified";
  32         }
  33
  34         var store = new Ext.data.Store({
  35             model: 'pve-fw-ipsets',
  36             proxy: {
  37                 type: 'proxmox',
  38                 url: "/api2/json" + me.base_url
  39             },
  40             sorters: {
  41                 property: 'name',
  42                 order: 'DESC'
  43             }
  44         });
  45
  46         var sm = Ext.create('Ext.selection.RowModel', {});
  47
  48         var reload = function() {
  49             var oldrec = sm.getSelection()[0];
  50             store.load(function(records, operation, success) {
  51                 if (oldrec) {
  52                     var rec = store.findRecord('name', oldrec.data.name);
  53                     if (rec) {
  54                         sm.select(rec);
  55                     }
  56                 }
  57             });
  58         };
  59
  60         var run_editor = function() {
  61             var rec = sm.getSelection()[0];
  62             if (!rec) {
  63                 return;
  64             }
  65             var win = Ext.create('Proxmox.window.Edit', {
  66                 subject: "IPSet '" + rec.data.name + "'",
  67                 url: me.base_url,
  68                 method: 'POST',
  69                 digest: rec.data.digest,
  70                 items: [
  71                     {
  72                         xtype: 'hiddenfield',
  73                         name: 'rename',
  74                         value: rec.data.name
  75                     },
  76                     {
  77                         xtype: 'textfield',
  78                         name: 'name',
  79                         value: rec.data.name,
  80                         fieldLabel: gettext('Name'),
  81                         allowBlank: false
  82                     },
  83                     {
  84                         xtype: 'textfield',
  85                         name: 'comment',
  86                         value: rec.data.comment,
  87                         fieldLabel: gettext('Comment')
  88                     }
  89                 ]
  90             });
  91             win.show();
  92             win.on('destroy', reload);
  93         };
  94
  95         me.editBtn = new Proxmox.button.Button({
  96             text: gettext('Edit'),
  97             disabled: true,
  98             selModel: sm,
  99             handler: run_editor
 100         });
 101
 102         me.addBtn = new Proxmox.button.Button({
 103             text: gettext('Create'),
 104             handler: function() {
 105                 sm.deselectAll();
 106                 var win = Ext.create('Proxmox.window.Edit', {
 107                     subject: 'IPSet',
 108                     url: me.base_url,
 109                     method: 'POST',
 110                     items: [
 111                         {
 112                             xtype: 'textfield',
 113                             name: 'name',
 114                             value: '',
 115                             fieldLabel: gettext('Name'),
 116                             allowBlank: false
 117                         },
 118                         {
 119                             xtype: 'textfield',
 120                             name: 'comment',
 121                             value: '',
 122                             fieldLabel: gettext('Comment')
 123                         }
 124                     ]
 125                 });
 126                 win.show();
 127                 win.on('destroy', reload);
 128
 129             }
 130         });
 131
 132         me.removeBtn = Ext.create('Proxmox.button.StdRemoveButton', {
 133             selModel: sm,
 134             baseurl: me.base_url + '/',
 135             callback: reload
 136         });
 137
 138         Ext.apply(me, {
 139             store: store,
 140             tbar: [ '<b>IPSet:</b>', me.addBtn, me.removeBtn, me.editBtn ],
 141             selModel: sm,
 142             columns: [
 143                 { header: 'IPSet', dataIndex: 'name', width: '100' },
 144                 { header: gettext('Comment'), dataIndex: 'comment', renderer: Ext.String.htmlEncode, flex: 1 }
 145             ],
 146             listeners: {
 147                 itemdblclick: run_editor,
 148                 select: function(sm, rec) {
 149                     var url = me.base_url + '/' + rec.data.name;
 150                     me.ipset_panel.setBaseUrl(url);
 151                 },
 152                 deselect: function() {
 153                     me.ipset_panel.setBaseUrl(undefined);
 154                 },
 155                 show: reload
 156             }
 157         });
 158
 159         me.callParent();
 160
 161         store.load();
 162     }
 163 });
 164
 165 Ext.define('PVE.IPSetCidrEdit', {
 166     extend: 'Proxmox.window.Edit',
 167
 168     cidr: undefined,
 169
 170     initComponent : function() {
 171
 172         var me = this;
 173
 174         me.isCreate = (me.cidr === undefined);
 175
 176
 177         if (me.isCreate) {
 178             me.url = '/api2/extjs' + me.base_url;
 179             me.method = 'POST';
 180         } else {
 181             me.url = '/api2/extjs' + me.base_url + '/' + me.cidr;
 182             me.method = 'PUT';
 183         }
 184
 185         var column1 = [];
 186
 187         if (me.isCreate) {
 188             if (!me.list_refs_url) {
 189                 throw "no alias_base_url specified";
 190             }
 191
 192             column1.push({
 193                 xtype: 'pveIPRefSelector',
 194                 name: 'cidr',
 195                 ref_type: 'alias',
 196                 autoSelect: false,
 197                 editable: true,
 198                 base_url: me.list_refs_url,
 199                 value: '',
 200                 fieldLabel: gettext('IP/CIDR')
 201             });
 202         } else {
 203             column1.push({
 204                 xtype: 'displayfield',
 205                 name: 'cidr',
 206                 value: '',
 207                 fieldLabel: gettext('IP/CIDR')
 208             });
 209         }
 210
 211         var ipanel = Ext.create('Proxmox.panel.InputPanel', {
 212             isCreate: me.isCreate,
 213             column1: column1,
 214             column2: [
 215                 {
 216                     xtype: 'proxmoxcheckbox',
 217                     name: 'nomatch',
 218                     checked: false,
 219                     uncheckedValue: 0,
 220                     fieldLabel: 'nomatch'
 221                 }
 222             ],
 223             columnB: [
 224                 {
 225                     xtype: 'textfield',
 226                     name: 'comment',
 227                     value: '',
 228                     fieldLabel: gettext('Comment')
 229                 }
 230             ]
 231         });
 232
 233         Ext.apply(me, {
 234             subject: gettext('IP/CIDR'),
 235             items: [ ipanel ]
 236         });
 237
 238         me.callParent();
 239
 240         if (!me.isCreate) {
 241             me.load({
 242                 success:  function(response, options) {
 243                     var values = response.result.data;
 244                     ipanel.setValues(values);
 245                 }
 246             });
 247         }
 248     }
 249 });
 250
 251 Ext.define('PVE.IPSetGrid', {
 252     extend: 'Ext.grid.Panel',
 253     alias: 'widget.pveIPSetGrid',
 254
 255     stateful: true,
 256     stateId: 'grid-firewall-ipsets',
 257
 258     base_url: undefined,
 259     list_refs_url: undefined,
 260
 261     addBtn: undefined,
 262     removeBtn: undefined,
 263     editBtn: undefined,
 264
 265     setBaseUrl: function(url) {
 266         var me = this;
 267
 268         me.base_url = url;
 269
 270         if (url === undefined) {
 271             me.addBtn.setDisabled(true);
 272             me.store.removeAll();
 273         } else {
 274             me.addBtn.setDisabled(false);
 275             me.removeBtn.baseurl = url + '/';
 276             me.store.setProxy({
 277                 type: 'proxmox',
 278                 url: '/api2/json' + url
 279             });
 280
 281             me.store.load();
 282         }
 283     },
 284
 285     initComponent: function() {
 286         var me = this;
 287
 288         if (!me.list_refs_url) {
 289             throw "no1 list_refs_url specified";
 290         }
 291
 292         var store = new Ext.data.Store({
 293             model: 'pve-ipset'
 294         });
 295
 296         var reload = function() {
 297             store.load();
 298         };
 299
 300         var sm = Ext.create('Ext.selection.RowModel', {});
 301
 302         var run_editor = function() {
 303             var rec = sm.getSelection()[0];
 304             if (!rec) {
 305                 return;
 306             }
 307             var win = Ext.create('PVE.IPSetCidrEdit', {
 308                 base_url: me.base_url,
 309                 cidr: rec.data.cidr
 310             });
 311             win.show();
 312             win.on('destroy', reload);
 313         };
 314
 315         me.editBtn = new Proxmox.button.Button({
 316             text: gettext('Edit'),
 317             disabled: true,
 318             selModel: sm,
 319             handler: run_editor
 320         });
 321
 322         me.addBtn = new Proxmox.button.Button({
 323             text: gettext('Add'),
 324             disabled: true,
 325             handler: function() {
 326                 if (!me.base_url) {
 327                     return;
 328                 }
 329                 var win = Ext.create('PVE.IPSetCidrEdit', {
 330                     base_url: me.base_url,
 331                     list_refs_url: me.list_refs_url
 332                 });
 333                 win.show();
 334                 win.on('destroy', reload);
 335             }
 336         });
 337
 338         me.removeBtn = Ext.create('Proxmox.button.StdRemoveButton', {
 339             selModel: sm,
 340             baseurl: me.base_url + '/',
 341             callback: reload
 342         });
 343
 344         var render_errors = function(value, metaData, record) {
 345             var errors = record.data.errors;
 346             if (errors) {
 347                 var msg = errors.cidr || errors.nomatch;
 348                 if (msg) {
 349                     metaData.tdCls = 'proxmox-invalid-row';
 350                     var html = '<p>' +  Ext.htmlEncode(msg) + '</p>';
 351                     metaData.tdAttr = 'data-qwidth=600 data-qtitle="ERROR" data-qtip="' +
 352                         html.replace(/\"/g,'&quot;') + '"';
 353                 }
 354             }
 355             return value;
 356         };
 357
 358         Ext.apply(me, {
 359             tbar: [ '<b>IP/CIDR:</b>', me.addBtn, me.removeBtn, me.editBtn ],
 360             store: store,
 361             selModel: sm,
 362             listeners: {
 363                 itemdblclick: run_editor
 364             },
 365             columns: [
 366                 {
 367                     xtype: 'rownumberer'
 368                 },
 369                 {
 370                     header: gettext('IP/CIDR'),
 371                     dataIndex: 'cidr',
 372                     width: 150,
 373                     renderer: function(value, metaData, record) {
 374                         value = render_errors(value, metaData, record);
 375                         if (record.data.nomatch) {
 376                             return '<b>! </b>' + value;
 377                         }
 378                         return value;
 379                     }
 380                 },
 381                 {
 382                     header: gettext('Comment'),
 383                     dataIndex: 'comment',
 384                     flex: 1,
 385                     renderer: function(value) {
 386                         return Ext.util.Format.htmlEncode(value);
 387                     }
 388                 }
 389             ]
 390         });
 391
 392         me.callParent();
 393
 394         if (me.base_url) {
 395             me.setBaseUrl(me.base_url); // load
 396         }
 397     }
 398 }, function() {
 399
 400     Ext.define('pve-ipset', {
 401         extend: 'Ext.data.Model',
 402         fields: [ { name: 'nomatch', type: 'boolean' },
 403                   'cidr', 'comment', 'errors' ],
 404         idProperty: 'cidr'
 405     });
 406
 407 });
 408
 409 Ext.define('PVE.IPSet', {
 410     extend: 'Ext.panel.Panel',
 411     alias: 'widget.pveIPSet',
 412
 413     title: 'IPSet',
 414
 415     onlineHelp: 'pve_firewall_ip_sets',
 416
 417     list_refs_url: undefined,
 418
 419     initComponent: function() {
 420         var me = this;
 421
 422         if (!me.list_refs_url) {
 423             throw "no list_refs_url specified";
 424         }
 425
 426         var ipset_panel = Ext.createWidget('pveIPSetGrid', {
 427             region: 'center',
 428             list_refs_url: me.list_refs_url,
 429             border: false
 430         });
 431
 432         var ipset_list = Ext.createWidget('pveIPSetList', {
 433             region: 'west',
 434             ipset_panel: ipset_panel,
 435             base_url: me.base_url,
 436             width: '50%',
 437             border: false,
 438             split: true
 439         });
 440
 441         Ext.apply(me, {
 442             layout: 'border',
 443             items: [ ipset_list, ipset_panel ],
 444             listeners: {
 445                 show: function() {
 446                     ipset_list.fireEvent('show', ipset_list);
 447                 }
 448             }
 449         });
 450
 451         me.callParent();
 452     }
 453 });