www/manager6/window/USBMapEdit.js

   1 Ext.define('PVE.window.USBMapEditWindow', {
   2     extend: 'Proxmox.window.Edit',
   3
   4     mixins: ['Proxmox.Mixin.CBind'],
   5
   6     cbindData: function(initialConfig) {
   7         let me = this;
   8         me.isCreate = !me.name;
   9         me.method = me.isCreate ? 'POST' : 'PUT';
  10         me.hideMapping = !!me.entryOnly;
  11         me.hideComment = me.name && !me.entryOnly;
  12         me.hideNodeSelector = me.nodename || me.entryOnly;
  13         me.hideNode = !me.nodename || !me.hideNodeSelector;
  14         return {
  15             name: me.name,
  16             nodename: me.nodename,
  17         };
  18     },
  19
  20     submitUrl: function(_url, data) {
  21         let me = this;
  22         let name = me.isCreate ? '' : me.name;
  23         return `/cluster/mapping/usb/${name}`;
  24     },
  25
  26     title: gettext('Add USB mapping'),
  27
  28     onlineHelp: 'resource_mapping',
  29
  30     method: 'POST',
  31
  32     controller: {
  33         xclass: 'Ext.app.ViewController',
  34
  35         onGetValues: function(values) {
  36             let me = this;
  37             let view = me.getView();
  38             values.node ??= view.nodename;
  39
  40             let type = me.getView().down('radiofield').getGroupValue();
  41             let name = values.name;
  42             let description = values.description;
  43             delete values.description;
  44             delete values.name;
  45
  46             if (type === 'path') {
  47                 let usbsel = me.lookup(type);
  48                 let usbDev = usbsel.getStore().findRecord('usbid', values[type], 0, false, true, true);
  49
  50                 if (!usbDev) {
  51                     return {};
  52                 }
  53                 values.id = `${usbDev.data.vendid}:${usbDev.data.prodid}`;
  54             }
  55
  56             let map = [];
  57             if (me.originalMap) {
  58                 map = PVE.Parser.filterPropertyStringList(me.originalMap, (e) => e.node !== values.node);
  59             }
  60             if (values.id) {
  61                 map.push(PVE.Parser.printPropertyString(values));
  62             }
  63
  64             values = { map };
  65             if (description) {
  66                 values.description = description;
  67             }
  68
  69             if (view.isCreate) {
  70                 values.id = name;
  71             }
  72
  73             return values;
  74         },
  75
  76         onSetValues: function(values) {
  77             let me = this;
  78             let view = me.getView();
  79             me.originalMap = [...values.map];
  80             let configuredNodes = [];
  81             PVE.Parser.filterPropertyStringList(values.map, (e) => {
  82                 configuredNodes.push(e.node);
  83                 if (e.node === view.nodename) {
  84                     values = e;
  85                 }
  86                 return false;
  87             });
  88
  89             me.lookup('nodeselector').disallowedNodes = configuredNodes;
  90             if (values.path) {
  91                 values.usb = 'path';
  92             }
  93
  94             return values;
  95         },
  96
  97         modeChange: function(field, value) {
  98             let me = this;
  99             let type = field.inputValue;
 100             let usbsel = me.lookup(type);
 101             usbsel.setDisabled(!value);
 102         },
 103
 104         nodeChange: function(_field, value) {
 105             this.lookup('id').setNodename(value);
 106             this.lookup('path').setNodename(value);
 107         },
 108
 109
 110         init: function(view) {
 111             let me = this;
 112
 113             if (!view.nodename) {
 114                 //throw "no nodename given";
 115             }
 116         },
 117
 118         control: {
 119             'radiofield': {
 120                 change: 'modeChange',
 121             },
 122             'pveNodeSelector': {
 123                 change: 'nodeChange',
 124             },
 125         },
 126     },
 127
 128     items: [
 129         {
 130             xtype: 'inputpanel',
 131             onGetValues: function(values) {
 132                 return this.up('window').getController().onGetValues(values);
 133             },
 134
 135             onSetValues: function(values) {
 136                 return this.up('window').getController().onSetValues(values);
 137             },
 138
 139             column1: [
 140                 {
 141                     xtype: 'pmxDisplayEditField',
 142                     fieldLabel: gettext('Name'),
 143                     cbind: {
 144                         editable: '{!name}',
 145                         value: '{name}',
 146                         submitValue: '{isCreate}',
 147                     },
 148                     name: 'name',
 149                     allowBlank: false,
 150                 },
 151                 {
 152                     xtype: 'displayfield',
 153                     fieldLabel: gettext('Mapping on Node'),
 154                     labelWidth: 120,
 155                     name: 'node',
 156                     cbind: {
 157                         value: '{nodename}',
 158                         disabled: '{hideNode}',
 159                         hidden: '{hideNode}',
 160                     },
 161                     allowBlank: false,
 162                 },
 163                 {
 164                     xtype: 'pveNodeSelector',
 165                     reference: 'nodeselector',
 166                     fieldLabel: gettext('Mapping on Node'),
 167                     labelWidth: 120,
 168                     name: 'node',
 169                     cbind: {
 170                         disabled: '{hideNodeSelector}',
 171                         hidden: '{hideNodeSelector}',
 172                     },
 173                     allowBlank: false,
 174                 },
 175             ],
 176
 177             column2: [
 178                 {
 179                     xtype: 'fieldcontainer',
 180                     defaultType: 'radiofield',
 181                     layout: 'fit',
 182                     cbind: {
 183                         disabled: '{hideMapping}',
 184                         hidden: '{hideMapping}',
 185                     },
 186                     items: [
 187                         {
 188                             name: 'usb',
 189                             inputValue: 'id',
 190                             checked: true,
 191                             boxLabel: gettext('Use USB Vendor/Device ID'),
 192                             submitValue: false,
 193                         },
 194                         {
 195                             xtype: 'pveUSBSelector',
 196                             type: 'device',
 197                             reference: 'id',
 198                             name: 'id',
 199                             cbind: {
 200                                 nodename: '{nodename}',
 201                                 disabled: '{hideMapping}',
 202                             },
 203                             editable: true,
 204                             allowBlank: false,
 205                             fieldLabel: gettext('Choose Device'),
 206                             labelAlign: 'right',
 207                         },
 208                         {
 209                             name: 'usb',
 210                             inputValue: 'path',
 211                             boxLabel: gettext('Use USB Port'),
 212                             submitValue: false,
 213                         },
 214                         {
 215                             xtype: 'pveUSBSelector',
 216                             disabled: true,
 217                             name: 'path',
 218                             reference: 'path',
 219                             cbind: {
 220                                 nodename: '{nodename}',
 221                             },
 222                             editable: true,
 223                             type: 'port',
 224                             allowBlank: false,
 225                             fieldLabel: gettext('Choose Port'),
 226                             labelAlign: 'right',
 227                         },
 228                     ],
 229                 },
 230             ],
 231
 232             columnB: [
 233                 {
 234                     xtype: 'proxmoxtextfield',
 235                     fieldLabel: gettext('Comment'),
 236                     submitValue: true,
 237                     name: 'description',
 238                     cbind: {
 239                         disabled: '{hideComment}',
 240                         hidden: '{hideComment}',
 241                     },
 242                 },
 243             ],
 244         },
 245     ],
 246 });