www/manager6/dc/StorageView.js

   1 Ext.define('PVE.dc.StorageView', {
   2     extend: 'Ext.grid.GridPanel',
   3
   4     alias: ['widget.pveStorageView'],
   5
   6     onlineHelp: 'chapter_storage',
   7
   8     stateful: true,
   9     stateId: 'grid-dc-storage',
  10
  11     createStorageEditWindow: function(type, sid) {
  12         let schema = PVE.Utils.storageSchema[type];
  13         if (!schema || !schema.ipanel) {
  14             throw "no editor registered for storage type: " + type;
  15         }
  16
  17         Ext.create('PVE.storage.BaseEdit', {
  18             paneltype: 'PVE.storage.' + schema.ipanel,
  19             type: type,
  20             storageId: sid,
  21             canDoBackups: schema.backups,
  22             autoShow: true,
  23             listeners: {
  24                 destroy: this.reloadStore,
  25             },
  26         });
  27     },
  28
  29     initComponent: function() {
  30         let me = this;
  31
  32         let store = new Ext.data.Store({
  33             model: 'pve-storage',
  34             proxy: {
  35                 type: 'proxmox',
  36                 url: "/api2/json/storage",
  37             },
  38             sorters: {
  39                 property: 'storage',
  40                 direction: 'ASC',
  41             },
  42         });
  43
  44         let sm = Ext.create('Ext.selection.RowModel', {});
  45
  46         let run_editor = function() {
  47             let rec = sm.getSelection()[0];
  48             if (!rec) {
  49                 return;
  50             }
  51             let { type, storage } = rec.data;
  52             me.createStorageEditWindow(type, storage);
  53         };
  54
  55         let edit_btn = new Proxmox.button.Button({
  56             text: gettext('Edit'),
  57             disabled: true,
  58             selModel: sm,
  59             handler: run_editor,
  60         });
  61         let remove_btn = Ext.create('Proxmox.button.StdRemoveButton', {
  62             selModel: sm,
  63             baseurl: '/storage/',
  64             callback: () => store.load(),
  65         });
  66
  67         // else we cannot dynamically generate the add menu handlers
  68         let addHandleGenerator = function(type) {
  69             return function() { me.createStorageEditWindow(type); };
  70         };
  71         let addMenuItems = [];
  72         for (const [type, storage] of Object.entries(PVE.Utils.storageSchema)) {
  73             if (storage.hideAdd) {
  74                 continue;
  75             }
  76             addMenuItems.push({
  77                 text: PVE.Utils.format_storage_type(type),
  78                 iconCls: 'fa fa-fw fa-' + storage.faIcon,
  79                 handler: addHandleGenerator(type),
  80             });
  81         }
  82
  83         Ext.apply(me, {
  84             store: store,
  85             reloadStore: () => store.load(),
  86             selModel: sm,
  87             viewConfig: {
  88                 trackOver: false,
  89             },
  90             tbar: [
  91                 {
  92                     text: gettext('Add'),
  93                     menu: new Ext.menu.Menu({
  94                         items: addMenuItems,
  95                     }),
  96                 },
  97                 remove_btn,
  98                 edit_btn,
  99             ],
 100             columns: [
 101                 {
 102                     header: 'ID',
 103                     flex: 2,
 104                     sortable: true,
 105                     dataIndex: 'storage',
 106                 },
 107                 {
 108                     header: gettext('Type'),
 109                     flex: 1,
 110                     sortable: true,
 111                     dataIndex: 'type',
 112                     renderer: PVE.Utils.format_storage_type,
 113                 },
 114                 {
 115                     header: gettext('Content'),
 116                     flex: 3,
 117                     sortable: true,
 118                     dataIndex: 'content',
 119                     renderer: PVE.Utils.format_content_types,
 120                 },
 121                 {
 122                     header: gettext('Path') + '/' + gettext('Target'),
 123                     flex: 2,
 124                     sortable: true,
 125                     dataIndex: 'path',
 126                     renderer: function(value, metaData, record) {
 127                         if (record.data.target) {
 128                             return record.data.target;
 129                         }
 130                         return value;
 131                     },
 132                 },
 133                 {
 134                     header: gettext('Shared'),
 135                     flex: 1,
 136                     sortable: true,
 137                     dataIndex: 'shared',
 138                     renderer: Proxmox.Utils.format_boolean,
 139                 },
 140                 {
 141                     header: gettext('Enabled'),
 142                     flex: 1,
 143                     sortable: true,
 144                     dataIndex: 'disable',
 145                     renderer: Proxmox.Utils.format_neg_boolean,
 146                 },
 147                 {
 148                     header: gettext('Bandwidth Limit'),
 149                     flex: 2,
 150                     sortable: true,
 151                     dataIndex: 'bwlimit',
 152                 },
 153             ],
 154             listeners: {
 155                 activate: () => store.load(),
 156                 itemdblclick: run_editor,
 157             },
 158         });
 159
 160         me.callParent();
 161     },
 162 }, function() {
 163     Ext.define('pve-storage', {
 164         extend: 'Ext.data.Model',
 165         fields: [
 166             'path', 'type', 'content', 'server', 'portal', 'target', 'export', 'storage',
 167             { name: 'shared', type: 'boolean' },
 168             { name: 'disable', type: 'boolean' },
 169         ],
 170         idProperty: 'storage',
 171     });
 172 });