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: 'pve',
  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('PVE.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 PVE.button.Button({
  96             text: gettext('Edit'),
  97             disabled: true,
  98             selModel: sm,
  99             handler: run_editor
 100         });
 101
 102         me.addBtn = new PVE.button.Button({
 103             text: gettext('Create'),
 104             handler: function() {
 105                 sm.deselectAll();
 106                 var win = Ext.create('PVE.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: 'PVE.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('PVE.panel.InputPanel', {
 212             isCreate: me.isCreate,
 213             column1: column1,
 214             column2: [
 215                 {
 216                     xtype: 'pvecheckbox',
 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: 'pve',
 278                 url: '/api2/json' + url
 279             });
 280
 281             me.store.load();
 282         }
 283     },
 284
 285     initComponent: function() {
 286         /*jslint confusion: true */
 287         var me = this;
 288
 289         if (!me.list_refs_url) {
 290             throw "no1 list_refs_url specified";
 291         }
 292
 293         var store = new Ext.data.Store({
 294             model: 'pve-ipset'
 295         });
 296
 297         var reload = function() {
 298             store.load();
 299         };
 300
 301         var sm = Ext.create('Ext.selection.RowModel', {});
 302
 303         var run_editor = function() {
 304             var rec = sm.getSelection()[0];
 305             if (!rec) {
 306                 return;
 307             }
 308             var win = Ext.create('PVE.IPSetCidrEdit', {
 309                 base_url: me.base_url,
 310                 cidr: rec.data.cidr
 311             });
 312             win.show();
 313             win.on('destroy', reload);
 314         };
 315
 316         me.editBtn = new PVE.button.Button({
 317             text: gettext('Edit'),
 318             disabled: true,
 319             selModel: sm,
 320             handler: run_editor
 321         });
 322
 323         me.addBtn = new PVE.button.Button({
 324             text: gettext('Add'),
 325             disabled: true,
 326             handler: function() {
 327                 if (!me.base_url) {
 328                     return;
 329                 }
 330                 var win = Ext.create('PVE.IPSetCidrEdit', {
 331                     base_url: me.base_url,
 332                     list_refs_url: me.list_refs_url
 333                 });
 334                 win.show();
 335                 win.on('destroy', reload);
 336             }
 337         });
 338
 339         me.removeBtn = Ext.create('Proxmox.button.StdRemoveButton', {
 340             selModel: sm,
 341             baseurl: me.base_url + '/',
 342             callback: reload
 343         });
 344
 345         var render_errors = function(value, metaData, record) {
 346             var errors = record.data.errors;
 347             if (errors) {
 348                 var msg = errors.cidr || errors.nomatch;
 349                 if (msg) {
 350                     metaData.tdCls = 'proxmox-invalid-row';
 351                     var html = '<p>' +  Ext.htmlEncode(msg) + '</p>';
 352                     metaData.tdAttr = 'data-qwidth=600 data-qtitle="ERROR" data-qtip="' +
 353                         html.replace(/\"/g,'&quot;') + '"';
 354                 }
 355             }
 356             return value;
 357         };
 358
 359         Ext.apply(me, {
 360             tbar: [ '<b>IP/CIDR:</b>', me.addBtn, me.removeBtn, me.editBtn ],
 361             store: store,
 362             selModel: sm,
 363             listeners: {
 364                 itemdblclick: run_editor
 365             },
 366             columns: [
 367                 {
 368                     xtype: 'rownumberer'
 369                 },
 370                 {
 371                     header: gettext('IP/CIDR'),
 372                     dataIndex: 'cidr',
 373                     width: 150,
 374                     renderer: function(value, metaData, record) {
 375                         value = render_errors(value, metaData, record);
 376                         if (record.data.nomatch) {
 377                             return '<b>! </b>' + value;
 378                         }
 379                         return value;
 380                     }
 381                 },
 382                 {
 383                     header: gettext('Comment'),
 384                     dataIndex: 'comment',
 385                     flex: 1,
 386                     renderer: function(value) {
 387                         return Ext.util.Format.htmlEncode(value);
 388                     }
 389                 }
 390             ]
 391         });
 392
 393         me.callParent();
 394
 395         if (me.base_url) {
 396             me.setBaseUrl(me.base_url); // load
 397         }
 398     }
 399 }, function() {
 400
 401     Ext.define('pve-ipset', {
 402         extend: 'Ext.data.Model',
 403         fields: [ { name: 'nomatch', type: 'boolean' },
 404                   'cidr', 'comment', 'errors' ],
 405         idProperty: 'cidr'
 406     });
 407
 408 });
 409
 410 Ext.define('PVE.IPSet', {
 411     extend: 'Ext.panel.Panel',
 412     alias: 'widget.pveIPSet',
 413
 414     title: 'IPSet',
 415
 416     onlineHelp: 'pve_firewall_ip_sets',
 417
 418     list_refs_url: undefined,
 419
 420     initComponent: function() {
 421         var me = this;
 422
 423         if (!me.list_refs_url) {
 424             throw "no list_refs_url specified";
 425         }
 426
 427         var ipset_panel = Ext.createWidget('pveIPSetGrid', {
 428             region: 'center',
 429             list_refs_url: me.list_refs_url,
 430             border: false
 431         });
 432
 433         var ipset_list = Ext.createWidget('pveIPSetList', {
 434             region: 'west',
 435             ipset_panel: ipset_panel,
 436             base_url: me.base_url,
 437             width: '50%',
 438             border: false,
 439             split: true
 440         });
 441
 442         Ext.apply(me, {
 443             layout: 'border',
 444             items: [ ipset_list, ipset_panel ],
 445             listeners: {
 446                 show: function() {
 447                     ipset_list.fireEvent('show', ipset_list);
 448                 }
 449             }
 450         });
 451
 452         me.callParent();
 453     }
 454 });