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 = new PVE.button.Button({
 133             text: gettext('Remove'),
 134             selModel: sm,
 135             disabled: true,
 136             handler: function() {
 137                 var rec = sm.getSelection()[0];
 138                 if (!rec || !me.base_url) {
 139                     return;
 140                 }
 141                 PVE.Utils.API2Request({
 142                     url: me.base_url + '/' + rec.data.name,
 143                     method: 'DELETE',
 144                     waitMsgTarget: me,
 145                     failure: function(response, options) {
 146                         Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 147                     },
 148                     callback: reload
 149                 });
 150             }
 151         });
 152
 153         Ext.apply(me, {
 154             store: store,
 155             tbar: [ '<b>IPSet:</b>', me.addBtn, me.removeBtn, me.editBtn ],
 156             selModel: sm,
 157             columns: [
 158                 { header: 'IPSet', dataIndex: 'name', width: '100' },
 159                 { header: gettext('Comment'), dataIndex: 'comment', renderer: Ext.String.htmlEncode, flex: 1 }
 160             ],
 161             listeners: {
 162                 itemdblclick: run_editor,
 163                 select: function(sm, rec) {
 164                     var url = me.base_url + '/' + rec.data.name;
 165                     me.ipset_panel.setBaseUrl(url);
 166                 },
 167                 deselect: function() {
 168                     me.ipset_panel.setBaseUrl(undefined);
 169                 },
 170                 show: reload
 171             }
 172         });
 173
 174         me.callParent();
 175
 176         store.load();
 177     }
 178 });
 179
 180 Ext.define('PVE.IPSetCidrEdit', {
 181     extend: 'PVE.window.Edit',
 182
 183     cidr: undefined,
 184
 185     initComponent : function() {
 186
 187         var me = this;
 188
 189         me.isCreate = (me.cidr === undefined);
 190
 191
 192         if (me.isCreate) {
 193             me.url = '/api2/extjs' + me.base_url;
 194             me.method = 'POST';
 195         } else {
 196             me.url = '/api2/extjs' + me.base_url + '/' + me.cidr;
 197             me.method = 'PUT';
 198         }
 199
 200         var column1 = [];
 201
 202         if (me.isCreate) {
 203             if (!me.list_refs_url) {
 204                 throw "no alias_base_url specified";
 205             }
 206
 207             column1.push({
 208                 xtype: 'pveIPRefSelector',
 209                 name: 'cidr',
 210                 ref_type: 'alias',
 211                 autoSelect: false,
 212                 editable: true,
 213                 base_url: me.list_refs_url,
 214                 value: '',
 215                 fieldLabel: gettext('IP/CIDR')
 216             });
 217         } else {
 218             column1.push({
 219                 xtype: 'displayfield',
 220                 name: 'cidr',
 221                 value: '',
 222                 fieldLabel: gettext('IP/CIDR')
 223             });
 224         }
 225
 226         var ipanel = Ext.create('PVE.panel.InputPanel', {
 227             isCreate: me.isCreate,
 228             column1: column1,
 229             column2: [
 230                 {
 231                     xtype: 'pvecheckbox',
 232                     name: 'nomatch',
 233                     checked: false,
 234                     uncheckedValue: 0,
 235                     fieldLabel: 'nomatch'
 236                 }
 237             ],
 238             columnB: [
 239                 {
 240                     xtype: 'textfield',
 241                     name: 'comment',
 242                     value: '',
 243                     fieldLabel: gettext('Comment')
 244                 }
 245             ]
 246         });
 247
 248         Ext.apply(me, {
 249             subject: gettext('IP/CIDR'),
 250             items: [ ipanel ]
 251         });
 252
 253         me.callParent();
 254
 255         if (!me.isCreate) {
 256             me.load({
 257                 success:  function(response, options) {
 258                     var values = response.result.data;
 259                     ipanel.setValues(values);
 260                 }
 261             });
 262         }
 263     }
 264 });
 265
 266 Ext.define('PVE.IPSetGrid', {
 267     extend: 'Ext.grid.Panel',
 268     alias: 'widget.pveIPSetGrid',
 269
 270     stateful: true,
 271     stateId: 'grid-firewall-ipsets',
 272
 273     base_url: undefined,
 274     list_refs_url: undefined,
 275
 276     addBtn: undefined,
 277     removeBtn: undefined,
 278     editBtn: undefined,
 279
 280     setBaseUrl: function(url) {
 281         var me = this;
 282
 283         me.base_url = url;
 284
 285         if (url === undefined) {
 286             me.addBtn.setDisabled(true);
 287             me.store.removeAll();
 288         } else {
 289             me.addBtn.setDisabled(false);
 290             me.store.setProxy({
 291                 type: 'pve',
 292                 url: '/api2/json' + url
 293             });
 294
 295             me.store.load();
 296         }
 297     },
 298
 299     initComponent: function() {
 300         /*jslint confusion: true */
 301         var me = this;
 302
 303         if (!me.list_refs_url) {
 304             throw "no1 list_refs_url specified";
 305         }
 306
 307         var store = new Ext.data.Store({
 308             model: 'pve-ipset'
 309         });
 310
 311         var reload = function() {
 312             store.load();
 313         };
 314
 315         var sm = Ext.create('Ext.selection.RowModel', {});
 316
 317         var run_editor = function() {
 318             var rec = sm.getSelection()[0];
 319             if (!rec) {
 320                 return;
 321             }
 322             var win = Ext.create('PVE.IPSetCidrEdit', {
 323                 base_url: me.base_url,
 324                 cidr: rec.data.cidr
 325             });
 326             win.show();
 327             win.on('destroy', reload);
 328         };
 329
 330         me.editBtn = new PVE.button.Button({
 331             text: gettext('Edit'),
 332             disabled: true,
 333             selModel: sm,
 334             handler: run_editor
 335         });
 336
 337         me.addBtn = new PVE.button.Button({
 338             text: gettext('Add'),
 339             disabled: true,
 340             handler: function() {
 341                 if (!me.base_url) {
 342                     return;
 343                 }
 344                 var win = Ext.create('PVE.IPSetCidrEdit', {
 345                     base_url: me.base_url,
 346                     list_refs_url: me.list_refs_url
 347                 });
 348                 win.show();
 349                 win.on('destroy', reload);
 350             }
 351         });
 352
 353         me.removeBtn = new PVE.button.Button({
 354             text: gettext('Remove'),
 355             selModel: sm,
 356             disabled: true,
 357             handler: function() {
 358                 var rec = sm.getSelection()[0];
 359                 if (!rec || !me.base_url) {
 360                     return;
 361                 }
 362
 363                 PVE.Utils.API2Request({
 364                     url: me.base_url + '/' + rec.data.cidr,
 365                     method: 'DELETE',
 366                     waitMsgTarget: me,
 367                     failure: function(response, options) {
 368                         Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 369                     },
 370                     callback: reload
 371                 });
 372             }
 373         });
 374
 375         var render_errors = function(value, metaData, record) {
 376             var errors = record.data.errors;
 377             if (errors) {
 378                 var msg = errors.cidr || errors.nomatch;
 379                 if (msg) {
 380                     metaData.tdCls = 'proxmox-invalid-row';
 381                     var html = '<p>' +  Ext.htmlEncode(msg) + '</p>';
 382                     metaData.tdAttr = 'data-qwidth=600 data-qtitle="ERROR" data-qtip="' +
 383                         html.replace(/\"/g,'&quot;') + '"';
 384                 }
 385             }
 386             return value;
 387         };
 388
 389         Ext.apply(me, {
 390             tbar: [ '<b>IP/CIDR:</b>', me.addBtn, me.removeBtn, me.editBtn ],
 391             store: store,
 392             selModel: sm,
 393             listeners: {
 394                 itemdblclick: run_editor
 395             },
 396             columns: [
 397                 {
 398                     xtype: 'rownumberer'
 399                 },
 400                 {
 401                     header: gettext('IP/CIDR'),
 402                     dataIndex: 'cidr',
 403                     width: 150,
 404                     renderer: function(value, metaData, record) {
 405                         value = render_errors(value, metaData, record);
 406                         if (record.data.nomatch) {
 407                             return '<b>! </b>' + value;
 408                         }
 409                         return value;
 410                     }
 411                 },
 412                 {
 413                     header: gettext('Comment'),
 414                     dataIndex: 'comment',
 415                     flex: 1,
 416                     renderer: function(value) {
 417                         return Ext.util.Format.htmlEncode(value);
 418                     }
 419                 }
 420             ]
 421         });
 422
 423         me.callParent();
 424
 425         if (me.base_url) {
 426             me.setBaseUrl(me.base_url); // load
 427         }
 428     }
 429 }, function() {
 430
 431     Ext.define('pve-ipset', {
 432         extend: 'Ext.data.Model',
 433         fields: [ { name: 'nomatch', type: 'boolean' },
 434                   'cidr', 'comment', 'errors' ],
 435         idProperty: 'cidr'
 436     });
 437
 438 });
 439
 440 Ext.define('PVE.IPSet', {
 441     extend: 'Ext.panel.Panel',
 442     alias: 'widget.pveIPSet',
 443
 444     title: 'IPSet',
 445
 446     onlineHelp: 'pve_firewall_ip_sets',
 447
 448     list_refs_url: undefined,
 449
 450     initComponent: function() {
 451         var me = this;
 452
 453         if (!me.list_refs_url) {
 454             throw "no list_refs_url specified";
 455         }
 456
 457         var ipset_panel = Ext.createWidget('pveIPSetGrid', {
 458             region: 'center',
 459             list_refs_url: me.list_refs_url,
 460             border: false
 461         });
 462
 463         var ipset_list = Ext.createWidget('pveIPSetList', {
 464             region: 'west',
 465             ipset_panel: ipset_panel,
 466             base_url: me.base_url,
 467             width: '50%',
 468             border: false,
 469             split: true
 470         });
 471
 472         Ext.apply(me, {
 473             layout: 'border',
 474             items: [ ipset_list, ipset_panel ],
 475             listeners: {
 476                 show: function() {
 477                     ipset_list.fireEvent('show', ipset_list);
 478                 }
 479             }
 480         });
 481
 482         me.callParent();
 483     }
 484 });