www/manager6/storage/CIFSEdit.js

   1 Ext.define('PVE.storage.CIFSScan', {
   2     extend: 'Ext.form.field.ComboBox',
   3     alias: 'widget.pveCIFSScan',
   4
   5     queryParam: 'server',
   6
   7     valueField: 'share',
   8     displayField: 'share',
   9     matchFieldWidth: false,
  10     listConfig: {
  11         loadingText: gettext('Scanning...'),
  12         width: 350,
  13     },
  14     doRawQuery: Ext.emptyFn,
  15
  16     onTriggerClick: function() {
  17         var me = this;
  18
  19         if (!me.queryCaching || me.lastQuery !== me.cifsServer) {
  20             me.store.removeAll();
  21         }
  22
  23         var params = {};
  24         if (me.cifsUsername) {
  25             params.username = me.cifsUsername;
  26         }
  27         if (me.cifsPassword) {
  28             params.password = me.cifsPassword;
  29         }
  30         if (me.cifsDomain) {
  31             params.domain = me.cifsDomain;
  32         }
  33
  34         me.store.getProxy().setExtraParams(params);
  35         me.allQuery = me.cifsServer;
  36
  37         me.callParent();
  38     },
  39
  40     resetProxy: function() {
  41         let me = this;
  42         me.lastQuery = null;
  43         if (!me.readOnly && !me.disabled) {
  44             if (me.isExpanded) {
  45                 me.collapse();
  46             }
  47         }
  48     },
  49
  50     setServer: function(server) {
  51         if (this.cifsServer !== server) {
  52             this.cifsServer = server;
  53             this.resetProxy();
  54         }
  55     },
  56     setUsername: function(username) {
  57         if (this.cifsUsername !== username) {
  58             this.cifsUsername = username;
  59             this.resetProxy();
  60         }
  61     },
  62     setPassword: function(password) {
  63         if (this.cifsPassword !== password) {
  64             this.cifsPassword = password;
  65             this.resetProxy();
  66         }
  67     },
  68     setDomain: function(domain) {
  69         if (this.cifsDomain !== domain) {
  70             this.cifsDomain = domain;
  71             this.resetProxy();
  72         }
  73     },
  74
  75     initComponent: function() {
  76         var me = this;
  77
  78         if (!me.nodename) {
  79             me.nodename = 'localhost';
  80         }
  81
  82         let store = Ext.create('Ext.data.Store', {
  83             fields: ['description', 'share'],
  84             proxy: {
  85                 type: 'proxmox',
  86                 url: '/api2/json/nodes/' + me.nodename + '/scan/cifs',
  87             },
  88         });
  89         store.sort('share', 'ASC');
  90
  91         Ext.apply(me, {
  92             store: store,
  93         });
  94
  95         me.callParent();
  96
  97         let picker = me.getPicker();
  98         // don't use monStoreErrors directly, it doesn't copes well with comboboxes
  99         picker.mon(store, 'beforeload', function(s, operation, eOpts) {
 100             picker.unmask();
 101             delete picker.minHeight;
 102         });
 103         picker.mon(store.proxy, 'afterload', function(proxy, request, success) {
 104             if (success) {
 105                 Proxmox.Utils.setErrorMask(picker, false);
 106                 return;
 107             }
 108             let error = request._operation.getError();
 109             let msg = Proxmox.Utils.getResponseErrorMessage(error);
 110             if (msg) {
 111                 picker.minHeight = 100;
 112             }
 113             Proxmox.Utils.setErrorMask(picker, msg);
 114         });
 115     },
 116 });
 117
 118 Ext.define('PVE.storage.CIFSInputPanel', {
 119     extend: 'PVE.panel.StorageBase',
 120
 121     onlineHelp: 'storage_cifs',
 122
 123     onGetValues: function(values) {
 124         let me = this;
 125
 126         if (values.password?.length === 0) {
 127             delete values.password;
 128         }
 129         if (values.username?.length === 0) {
 130             delete values.username;
 131         }
 132         if (values.subdir?.length === 0) {
 133             delete values.subdir;
 134         }
 135
 136         return me.callParent([values]);
 137     },
 138
 139     initComponent: function() {
 140         var me = this;
 141
 142         me.column1 = [
 143             {
 144                 xtype: me.isCreate ? 'textfield' : 'displayfield',
 145                 name: 'server',
 146                 value: '',
 147                 fieldLabel: gettext('Server'),
 148                 allowBlank: false,
 149                 listeners: {
 150                     change: function(f, value) {
 151                         if (me.isCreate) {
 152                             var exportField = me.down('field[name=share]');
 153                             exportField.setServer(value);
 154                         }
 155                     },
 156                 },
 157             },
 158             {
 159                 xtype: me.isCreate ? 'textfield' : 'displayfield',
 160                 name: 'username',
 161                 value: '',
 162                 fieldLabel: gettext('Username'),
 163                 emptyText: gettext('Guest user'),
 164                 listeners: {
 165                     change: function(f, value) {
 166                         if (!me.isCreate) {
 167                             return;
 168                         }
 169                         var exportField = me.down('field[name=share]');
 170                         exportField.setUsername(value);
 171                     },
 172                 },
 173             },
 174             {
 175                 xtype: me.isCreate ? 'textfield' : 'displayfield',
 176                 inputType: 'password',
 177                 name: 'password',
 178                 value: me.isCreate ? '' : '********',
 179                 emptyText: me.isCreate ? gettext('None') : '',
 180                 fieldLabel: gettext('Password'),
 181                 minLength: 1,
 182                 listeners: {
 183                     change: function(f, value) {
 184                         let exportField = me.down('field[name=share]');
 185                         exportField.setPassword(value);
 186                     },
 187                 },
 188             },
 189             {
 190                 xtype: me.isCreate ? 'pveCIFSScan' : 'displayfield',
 191                 name: 'share',
 192                 value: '',
 193                 fieldLabel: 'Share',
 194                 allowBlank: false,
 195             },
 196         ];
 197
 198         me.column2 = [
 199             {
 200                 xtype: 'pveContentTypeSelector',
 201                 name: 'content',
 202                 value: 'images',
 203                 multiSelect: true,
 204                 fieldLabel: gettext('Content'),
 205                 allowBlank: false,
 206             },
 207             {
 208                 xtype: me.isCreate ? 'textfield' : 'displayfield',
 209                 name: 'domain',
 210                 value: me.isCreate ? '' : undefined,
 211                 fieldLabel: gettext('Domain'),
 212                 allowBlank: true,
 213                 listeners: {
 214                     change: function(f, value) {
 215                         if (me.isCreate) {
 216                             let exportField = me.down('field[name=share]');
 217                             exportField.setDomain(value);
 218                         }
 219                     },
 220                 },
 221             },
 222             {
 223                 xtype: 'pmxDisplayEditField',
 224                 editable: me.isCreate,
 225                 name: 'subdir',
 226                 fieldLabel: gettext('Subdirectory'),
 227                 allowBlank: true,
 228                 emptyText: gettext('/some/path'),
 229             },
 230         ];
 231
 232         me.callParent();
 233     },
 234 });