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: function() {
  15     },
  16
  17     onTriggerClick: function() {
  18         var me = this;
  19
  20         if (!me.queryCaching || me.lastQuery !== me.cifsServer) {
  21             me.store.removeAll();
  22         }
  23
  24         var params = {};
  25         if (me.cifsUsername && me.cifsPassword) {
  26             params.username =  me.cifsUsername;
  27             params.password = me.cifsPassword;
  28         }
  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     setServer: function(server) {
  41         var me = this;
  42
  43         me.cifsServer = server;
  44     },
  45
  46     setUsername: function(username) {
  47         var me = this;
  48
  49         me.cifsUsername = username;
  50     },
  51
  52     setPassword: function(password) {
  53         var me = this;
  54
  55         me.cifsPassword = password;
  56     },
  57
  58     setDomain: function(domain) {
  59         var me = this;
  60
  61         me.cifsDomain = domain;
  62     },
  63
  64     initComponent : function() {
  65         var me = this;
  66
  67         if (!me.nodename) {
  68             me.nodename = 'localhost';
  69         }
  70
  71         var store = Ext.create('Ext.data.Store', {
  72             fields: ['description', 'share'],
  73             proxy: {
  74                 type: 'proxmox',
  75                 url: '/api2/json/nodes/' + me.nodename + '/scan/cifs'
  76             }
  77         });
  78         store.sort('share', 'ASC');
  79
  80         Ext.apply(me, {
  81             store: store
  82         });
  83
  84         me.callParent();
  85     }
  86 });
  87
  88 Ext.define('PVE.storage.CIFSInputPanel', {
  89     extend: 'Proxmox.panel.InputPanel',
  90     controller: 'storageEdit',
  91
  92     onGetValues: function(values) {
  93         var me = this;
  94
  95         if (me.isCreate) {
  96             values.type = 'cifs';
  97         } else {
  98             delete values.storage;
  99         }
 100
 101         values.disable = values.enable ? 0 : 1;
 102         delete values.enable;
 103
 104         return values;
 105     },
 106
 107     initComponent : function() {
 108         var me = this;
 109
 110         var passwordfield = Ext.createWidget(me.isCreate ? 'textfield' : 'displayfield', {
 111             inputType: 'password',
 112             name: 'password',
 113             value: me.isCreate ? '' : '********',
 114             fieldLabel: gettext('Password'),
 115             allowBlank: true,
 116             minLength: 1,
 117             listeners: {
 118                 change: function(f, value) {
 119
 120                     if (me.isCreate) {
 121                         var exportField = me.down('field[name=share]');
 122                         exportField.setPassword(value);
 123                     }
 124                 }
 125             }
 126         });
 127
 128         me.column1 = [
 129             {
 130                 xtype: me.isCreate ? 'textfield' : 'displayfield',
 131                 name: 'storage',
 132                 value: me.storageId || '',
 133                 fieldLabel: 'ID',
 134                 vtype: 'StorageId',
 135                 allowBlank: false
 136             },
 137             {
 138                 xtype: me.isCreate ? 'textfield' : 'displayfield',
 139                 name: 'server',
 140                 value: '',
 141                 fieldLabel: gettext('Server'),
 142                 allowBlank: false,
 143                 listeners: {
 144                     change: function(f, value) {
 145                         if (me.isCreate) {
 146                             var exportField = me.down('field[name=share]');
 147                             exportField.setServer(value);
 148                         }
 149                     }
 150                 }
 151             },
 152             {
 153                 xtype: me.isCreate ? 'textfield' : 'displayfield',
 154                 name: 'username',
 155                 value: '',
 156                 fieldLabel: gettext('Username'),
 157                 emptyText: gettext('Guest user'),
 158                 allowBlank: true,
 159                 listeners: {
 160                     change: function(f, value) {
 161                         if (me.isCreate) {
 162                             var exportField = me.down('field[name=share]');
 163                             exportField.setUsername(value);
 164                         }
 165                         if (value == "") {
 166                             passwordfield.allowBlank = true;
 167                         } else {
 168                             passwordfield.allowBlank = false;
 169                         }
 170                         passwordfield.validate();
 171                     }
 172                 }
 173             },
 174             {
 175                 xtype: me.isCreate ? 'pveCIFSScan' : 'displayfield',
 176                 name: 'share',
 177                 value: '',
 178                 fieldLabel: 'Share',
 179                 allowBlank: false
 180             },
 181             {
 182                 xtype: 'pveContentTypeSelector',
 183                 name: 'content',
 184                 value: 'images',
 185                 multiSelect: true,
 186                 fieldLabel: gettext('Content'),
 187                 allowBlank: false
 188             }
 189         ];
 190
 191         me.column2 = [
 192             {
 193                 xtype: 'pveNodeSelector',
 194                 name: 'nodes',
 195                 fieldLabel: gettext('Nodes'),
 196                 emptyText: gettext('All') + ' (' +
 197                     gettext('No restrictions') +')',
 198                 multiSelect: true,
 199                 autoSelect: false
 200             },
 201             {
 202                 xtype: 'proxmoxcheckbox',
 203                 name: 'enable',
 204                 checked: true,
 205                 uncheckedValue: 0,
 206                 fieldLabel: gettext('Enable')
 207             },
 208             {
 209                 xtype: 'proxmoxintegerfield',
 210                 fieldLabel: gettext('Max Backups'),
 211                 name: 'maxfiles',
 212                 reference: 'maxfiles',
 213                 minValue: 0,
 214                 maxValue: 365,
 215                 value: me.isCreate ? '1' : undefined,
 216                 allowBlank: false
 217             },
 218             passwordfield,
 219             {
 220                 xtype: me.isCreate ? 'textfield' : 'displayfield',
 221                 name: 'domain',
 222                 value: me.isCreate ? '' : undefined,
 223                 fieldLabel: gettext('Domain'),
 224                 allowBlank: true,
 225                 listeners: {
 226                     change: function(f, value) {
 227                         if (me.isCreate) {
 228
 229                             var exportField = me.down('field[name=share]');
 230                             exportField.setDomain(value);
 231                         }
 232                     }
 233                 }
 234             }
 235         ];
 236
 237         me.callParent();
 238     }
 239 });
 240
 241 Ext.define('PVE.storage.CIFSEdit', {
 242     extend: 'Proxmox.window.Edit',
 243
 244     initComponent : function() {
 245         var me = this;
 246
 247         me.isCreate = !me.storageId;
 248
 249         if (me.isCreate) {
 250             me.url = '/api2/extjs/storage';
 251             me.method = 'POST';
 252         } else {
 253             me.url = '/api2/extjs/storage/' + me.storageId;
 254             me.method = 'PUT';
 255         }
 256
 257         var ipanel = Ext.create('PVE.storage.CIFSInputPanel', {
 258             isCreate: me.isCreate,
 259             storageId: me.storageId
 260         });
 261
 262         Ext.apply(me, {
 263             subject: 'CIFS',
 264             isAdd: true,
 265             items: [ ipanel ]
 266         });
 267
 268         me.callParent();
 269
 270         if (!me.isCreate) {
 271             me.load({
 272                 success:  function(response, options) {
 273                     var values = response.result.data;
 274                     var ctypes = values.content || '';
 275
 276                     values.content = ctypes.split(',');
 277
 278                     if (values.nodes) {
 279                         values.nodes = values.nodes.split(',');
 280                     }
 281                     values.enable = values.disable ? 0 : 1;
 282                     ipanel.setValues(values);
 283                 }
 284             });
 285         }
 286     }
 287 });