www/manager6/sdn/ZoneView.js

   1 Ext.define('PVE.sdn.ZoneView', {
   2     extend: 'Ext.grid.GridPanel',
   3     alias: ['widget.pveSDNZoneView'],
   4
   5     onlineHelp: 'pvesdn_config_zone',
   6
   7     stateful: true,
   8     stateId: 'grid-sdn-zone',
   9
  10     createSDNEditWindow: function(type, sid) {
  11         let schema = PVE.Utils.sdnzoneSchema[type];
  12         if (!schema || !schema.ipanel) {
  13             throw "no editor registered for zone type: " + type;
  14         }
  15
  16         Ext.create('PVE.sdn.zones.BaseEdit', {
  17             paneltype: 'PVE.sdn.zones.' + schema.ipanel,
  18             type: type,
  19             zone: sid,
  20             autoShow: true,
  21             listeners: {
  22                 destroy: this.reloadStore,
  23             },
  24         });
  25     },
  26
  27     initComponent: function() {
  28         let me = this;
  29
  30         let store = new Ext.data.Store({
  31             model: 'pve-sdn-zone',
  32             proxy: {
  33                 type: 'proxmox',
  34                 url: "/api2/json/cluster/sdn/zones?pending=1",
  35             },
  36             sorters: {
  37                 property: 'zone',
  38                 direction: 'ASC',
  39             },
  40         });
  41
  42         let reload = function() {
  43             store.load();
  44         };
  45
  46         let sm = Ext.create('Ext.selection.RowModel', {});
  47
  48         let run_editor = function() {
  49             let rec = sm.getSelection()[0];
  50             if (!rec) {
  51                 return;
  52             }
  53             let type = rec.data.type,
  54                 zone = rec.data.zone;
  55
  56             me.createSDNEditWindow(type, zone);
  57         };
  58
  59         let edit_btn = new Proxmox.button.Button({
  60             text: gettext('Edit'),
  61             disabled: true,
  62             selModel: sm,
  63             handler: run_editor,
  64         });
  65
  66         let remove_btn = Ext.create('Proxmox.button.StdRemoveButton', {
  67             selModel: sm,
  68             baseurl: '/cluster/sdn/zones/',
  69             callback: reload,
  70         });
  71
  72         let set_button_status = function() {
  73             var rec = me.selModel.getSelection()[0];
  74
  75             if (!rec || rec.data.state === 'deleted') {
  76                 edit_btn.disable();
  77                 remove_btn.disable();
  78             }
  79         };
  80
  81         // else we cannot dynamically generate the add menu handlers
  82         let addHandleGenerator = function(type) {
  83             return function() { me.createSDNEditWindow(type); };
  84         };
  85         let addMenuItems = [];
  86         for (const [type, zone] of Object.entries(PVE.Utils.sdnzoneSchema)) {
  87             if (zone.hideAdd) {
  88                 continue;
  89             }
  90             addMenuItems.push({
  91                 text: PVE.Utils.format_sdnzone_type(type),
  92                 iconCls: 'fa fa-fw fa-' + zone.faIcon,
  93                 handler: addHandleGenerator(type),
  94             });
  95         }
  96
  97         Ext.apply(me, {
  98             store: store,
  99             reloadStore: reload,
 100             selModel: sm,
 101             viewConfig: {
 102                 trackOver: false,
 103             },
 104             tbar: [
 105                 {
 106                     text: gettext('Add'),
 107                     menu: new Ext.menu.Menu({
 108                         items: addMenuItems,
 109                     }),
 110                 },
 111                 remove_btn,
 112                 edit_btn,
 113             ],
 114             columns: [
 115                 {
 116                     header: 'ID',
 117                     width: 100,
 118                     dataIndex: 'zone',
 119                     renderer: function(value, metaData, rec) {
 120                         return PVE.Utils.render_sdn_pending(rec, value, 'zone', 1);
 121                     },
 122                 },
 123                 {
 124                     header: gettext('Type'),
 125                     width: 100,
 126                     dataIndex: 'type',
 127                     renderer: function(value, metaData, rec) {
 128                         return PVE.Utils.render_sdn_pending(rec, value, 'type', 1);
 129                     },
 130                 },
 131                 {
 132                     header: 'MTU',
 133                     width: 50,
 134                     dataIndex: 'mtu',
 135                     renderer: function(value, metaData, rec) {
 136                         return PVE.Utils.render_sdn_pending(rec, value, 'mtu');
 137                     },
 138                 },
 139                 {
 140                     header: 'Ipam',
 141                     flex: 3,
 142                     dataIndex: 'ipam',
 143                     renderer: function(value, metaData, rec) {
 144                         return PVE.Utils.render_sdn_pending(rec, value, 'ipam');
 145                     },
 146                 },
 147                 {
 148                     header: gettext('Domain'),
 149                     flex: 3,
 150                     dataIndex: 'dnszone',
 151                     renderer: function(value, metaData, rec) {
 152                         return PVE.Utils.render_sdn_pending(rec, value, 'dnszone');
 153                     },
 154                 },
 155                 {
 156                     header: gettext('Dns'),
 157                     flex: 3,
 158                     dataIndex: 'dns',
 159                     renderer: function(value, metaData, rec) {
 160                         return PVE.Utils.render_sdn_pending(rec, value, 'dns');
 161                     },
 162                 },
 163                 {
 164                     header: gettext('Reverse dns'),
 165                     flex: 3,
 166                     dataIndex: 'reversedns',
 167                     renderer: function(value, metaData, rec) {
 168                         return PVE.Utils.render_sdn_pending(rec, value, 'reversedns');
 169                     },
 170                 },
 171                 {
 172                     header: gettext('Nodes'),
 173                     flex: 3,
 174                     dataIndex: 'nodes',
 175                     renderer: function(value, metaData, rec) {
 176                         return PVE.Utils.render_sdn_pending(rec, value, 'nodes');
 177                     },
 178                 },
 179                 {
 180                     header: gettext('State'),
 181                     width: 100,
 182                     dataIndex: 'state',
 183                     renderer: function(value, metaData, rec) {
 184                         return PVE.Utils.render_sdn_pending_state(rec, value);
 185                     },
 186                 },
 187             ],
 188             listeners: {
 189                 activate: reload,
 190                 itemdblclick: run_editor,
 191                 selectionchange: set_button_status,
 192             },
 193         });
 194
 195         me.callParent();
 196     },
 197 });