www/manager6/form/USBSelector.js

   1 Ext.define('PVE.form.USBSelector', {
   2     extend: 'Proxmox.form.ComboGrid',
   3     alias: ['widget.pveUSBSelector'],
   4
   5     allowBlank: false,
   6     autoSelect: false,
   7     anyMatch: true,
   8     displayField: 'product_and_id',
   9     valueField: 'usbid',
  10     editable: true,
  11
  12     validator: function(value) {
  13         var me = this;
  14         if (!value) {
  15             return true; // handled later by allowEmpty in the getErrors call chain
  16         }
  17         value = me.getValue(); // as the valueField is not the displayfield
  18         if (me.type === 'device') {
  19             return (/^[a-f0-9]{4}:[a-f0-9]{4}$/i).test(value);
  20         } else if (me.type === 'port') {
  21             return (/^[0-9]+-[0-9]+(\.[0-9]+)*$/).test(value);
  22         }
  23         return gettext("Invalid Value");
  24     },
  25
  26     setNodename: function(nodename) {
  27         var me = this;
  28
  29         if (!nodename || me.nodename === nodename) {
  30             return;
  31         }
  32
  33         me.nodename = nodename;
  34
  35         me.store.setProxy({
  36             type: 'proxmox',
  37             url: `/api2/json/nodes/${me.nodename}/hardware/usb`,
  38         });
  39
  40         me.store.load();
  41     },
  42
  43     initComponent: function() {
  44         var me = this;
  45
  46         if (me.pveSelNode) {
  47             me.nodename = me.pveSelNode.data.node;
  48         }
  49
  50         var nodename = me.nodename;
  51         me.nodename = undefined;
  52
  53         if (me.type !== 'device' && me.type !== 'port') {
  54             throw "no valid type specified";
  55         }
  56
  57         let store = new Ext.data.Store({
  58             model: `pve-usb-${me.type}`,
  59             filters: [
  60                 ({ data }) => !!data.usbpath && !!data.prodid && String(data.class) !== "9",
  61             ],
  62         });
  63         let emptyText = '';
  64         if (me.type === 'device') {
  65             emptyText = gettext('Passthrough a specific device');
  66         } else {
  67             emptyText = gettext('Passthrough a full port');
  68         }
  69
  70         Ext.apply(me, {
  71             store: store,
  72             emptyText: emptyText,
  73             listConfig: {
  74                 minHeight: 80,
  75                 width: 520,
  76                 columns: [
  77                     {
  78                         header: me.type === 'device'?gettext('Device'):gettext('Port'),
  79                         sortable: true,
  80                         dataIndex: 'usbid',
  81                         width: 80,
  82                     },
  83                     {
  84                         header: gettext('Manufacturer'),
  85                         sortable: true,
  86                         dataIndex: 'manufacturer',
  87                         width: 150,
  88                     },
  89                     {
  90                         header: gettext('Product'),
  91                         sortable: true,
  92                         dataIndex: 'product',
  93                         flex: 1,
  94                     },
  95                     {
  96                         header: gettext('Speed'),
  97                         width: 75,
  98                         sortable: true,
  99                         dataIndex: 'speed',
 100                         renderer: function(value) {
 101                             let speed2Class = {
 102                                 "10000": "USB 3.1",
 103                                 "5000": "USB 3.0",
 104                                 "480": "USB 2.0",
 105                                 "12": "USB 1.x",
 106                                 "1.5": "USB 1.x",
 107                             };
 108                             return speed2Class[value] || value + " Mbps";
 109                         },
 110                     },
 111                 ],
 112             },
 113         });
 114
 115         me.callParent();
 116
 117         me.setNodename(nodename);
 118     },
 119
 120 }, function() {
 121     Ext.define('pve-usb-device', {
 122         extend: 'Ext.data.Model',
 123         fields: [
 124             {
 125                 name: 'usbid',
 126                 convert: function(val, data) {
 127                     if (val) {
 128                         return val;
 129                     }
 130                     return data.get('vendid') + ':' + data.get('prodid');
 131                 },
 132             },
 133             'speed', 'product', 'manufacturer', 'vendid', 'prodid', 'usbpath',
 134             { name: 'port', type: 'number' },
 135             { name: 'level', type: 'number' },
 136             { name: 'class', type: 'number' },
 137             { name: 'devnum', type: 'number' },
 138             { name: 'busnum', type: 'number' },
 139             {
 140                 name: 'product_and_id',
 141                 type: 'string',
 142                 convert: (v, rec) => {
 143                     let res = rec.data.product || gettext('Unknown');
 144                     res += " (" + rec.data.usbid + ")";
 145                     return res;
 146                 },
 147             },
 148         ],
 149     });
 150
 151     Ext.define('pve-usb-port', {
 152         extend: 'Ext.data.Model',
 153         fields: [
 154             {
 155                 name: 'usbid',
 156                 convert: function(val, data) {
 157                     if (val) {
 158                         return val;
 159                     }
 160                     return data.get('busnum') + '-' + data.get('usbpath');
 161                 },
 162             },
 163             'speed', 'product', 'manufacturer', 'vendid', 'prodid', 'usbpath',
 164             { name: 'port', type: 'number' },
 165             { name: 'level', type: 'number' },
 166             { name: 'class', type: 'number' },
 167             { name: 'devnum', type: 'number' },
 168             { name: 'busnum', type: 'number' },
 169             {
 170                 name: 'product_and_id',
 171                 type: 'string',
 172                 convert: (v, rec) => {
 173                     let res = rec.data.product || gettext('Unplugged');
 174                     res += " (" + rec.data.usbid + ")";
 175                     return res;
 176                 },
 177             },
 178         ],
 179     });
 180 });