www/manager6/window/DownloadUrlToStorage.js

   1 Ext.define('PVE.window.DownloadUrlToStorage', {
   2     extend: 'Proxmox.window.Edit',
   3     alias: 'widget.pveStorageDownloadUrl',
   4     mixins: ['Proxmox.Mixin.CBind'],
   5
   6     isCreate: true,
   7
   8     method: 'POST',
   9
  10     showTaskViewer: true,
  11
  12     title: gettext('Download from URL'),
  13     submitText: gettext('Download'),
  14
  15     cbindData: function(initialConfig) {
  16         var me = this;
  17         return {
  18             nodename: me.nodename,
  19             storage: me.storage,
  20             content: me.content,
  21         };
  22     },
  23
  24     cbind: {
  25         url: '/nodes/{nodename}/storage/{storage}/download-url',
  26     },
  27
  28
  29     viewModel: {
  30         data: {
  31             size: '-',
  32             mimetype: '-',
  33             enableQuery: true,
  34         },
  35     },
  36
  37     controller: {
  38         xclass: 'Ext.app.ViewController',
  39
  40         urlChange: function(field) {
  41             this.resetMetaInfo();
  42             this.setQueryEnabled();
  43         },
  44         setQueryEnabled: function() {
  45             this.getViewModel().set('enableQuery', true);
  46         },
  47         resetMetaInfo: function() {
  48             let vm = this.getViewModel();
  49             vm.set('size', '-');
  50             vm.set('mimetype', '-');
  51         },
  52
  53         urlCheck: function(field) {
  54             let me = this;
  55             let view = me.getView();
  56
  57             const queryParam = view.getValues();
  58
  59             me.getViewModel().set('enableQuery', false);
  60             me.resetMetaInfo();
  61             let urlField = view.down('[name=url]');
  62
  63             Proxmox.Utils.API2Request({
  64                 url: `/nodes/${view.nodename}/query-url-metadata`,
  65                 method: 'GET',
  66                 params: {
  67                     url: queryParam.url,
  68                     'verify-certificates': queryParam['verify-certificates'],
  69                 },
  70                 waitMsgTarget: view,
  71                 failure: res => {
  72                     urlField.setValidation(res.result.message);
  73                     urlField.validate();
  74                     Ext.MessageBox.alert(gettext('Error'), res.htmlStatus);
  75                     // re-enable so one can directly requery, e.g., if it was just a network hiccup
  76                     me.setQueryEnabled();
  77                 },
  78                 success: function(res, opt) {
  79                     urlField.setValidation();
  80                     urlField.validate();
  81
  82                     let data = res.result.data;
  83
  84                     let filename = data.filename || "";
  85                     let compression = '__default__';
  86                     if (view.content === 'iso') {
  87                         const matches = filename.match(/^(.+)\.(gz|lzo|zst)$/i);
  88                         if (matches) {
  89                             filename = matches[1];
  90                             compression = matches[2].toLowerCase();
  91                         }
  92                     }
  93
  94                     view.setValues({
  95                         filename,
  96                         compression,
  97                         size: (data.size && Proxmox.Utils.format_size(data.size)) || gettext("Unknown"),
  98                         mimetype: data.mimetype || gettext("Unknown"),
  99                     });
 100                 },
 101             });
 102         },
 103
 104         hashChange: function(field) {
 105             let checksum = Ext.getCmp('downloadUrlChecksum');
 106             if (field.getValue() === '__default__') {
 107                 checksum.setDisabled(true);
 108                 checksum.setValue("");
 109                 checksum.allowBlank = true;
 110             } else {
 111                 checksum.setDisabled(false);
 112                 checksum.allowBlank = false;
 113             }
 114         },
 115     },
 116
 117     items: [
 118         {
 119             xtype: 'inputpanel',
 120             border: false,
 121             onGetValues: function(values) {
 122                 if (typeof values.checksum === 'string') {
 123                     values.checksum = values.checksum.trim();
 124                 }
 125                 return values;
 126             },
 127             columnT: [
 128                 {
 129                     xtype: 'fieldcontainer',
 130                     layout: 'hbox',
 131                     fieldLabel: gettext('URL'),
 132                     items: [
 133                         {
 134                             xtype: 'textfield',
 135                             name: 'url',
 136                             emptyText: gettext("Enter URL to download"),
 137                             allowBlank: false,
 138                             flex: 1,
 139                             listeners: {
 140                                 change: 'urlChange',
 141                             },
 142                         },
 143                         {
 144                             xtype: 'button',
 145                             name: 'check',
 146                             text: gettext('Query URL'),
 147                             margin: '0 0 0 5',
 148                             bind: {
 149                                 disabled: '{!enableQuery}',
 150                             },
 151                             listeners: {
 152                                 click: 'urlCheck',
 153                             },
 154                         },
 155                     ],
 156                 },
 157                 {
 158                     xtype: 'textfield',
 159                     name: 'filename',
 160                     allowBlank: false,
 161                     fieldLabel: gettext('File name'),
 162                     emptyText: gettext("Please (re-)query URL to get meta information"),
 163                 },
 164             ],
 165             column1: [
 166                 {
 167                     xtype: 'displayfield',
 168                     name: 'size',
 169                     fieldLabel: gettext('File size'),
 170                     bind: {
 171                         value: '{size}',
 172                     },
 173                 },
 174             ],
 175             column2: [
 176                 {
 177                     xtype: 'displayfield',
 178                     name: 'mimetype',
 179                     fieldLabel: gettext('MIME type'),
 180                     bind: {
 181                         value: '{mimetype}',
 182                     },
 183                 },
 184             ],
 185             advancedColumn1: [
 186                 {
 187                     xtype: 'pveHashAlgorithmSelector',
 188                     name: 'checksum-algorithm',
 189                     fieldLabel: gettext('Hash algorithm'),
 190                     allowBlank: true,
 191                     hasNoneOption: true,
 192                     value: '__default__',
 193                     listeners: {
 194                         change: 'hashChange',
 195                     },
 196                 },
 197                 {
 198                     xtype: 'textfield',
 199                     name: 'checksum',
 200                     fieldLabel: gettext('Checksum'),
 201                     allowBlank: true,
 202                     disabled: true,
 203                     emptyText: gettext('none'),
 204                     id: 'downloadUrlChecksum',
 205                 },
 206             ],
 207             advancedColumn2: [
 208                 {
 209                     xtype: 'proxmoxcheckbox',
 210                     name: 'verify-certificates',
 211                     fieldLabel: gettext('Verify certificates'),
 212                     uncheckedValue: 0,
 213                     checked: true,
 214                     listeners: {
 215                         change: 'setQueryEnabled',
 216                     },
 217                 },
 218                 {
 219                     xtype: 'proxmoxKVComboBox',
 220                     name: 'compression',
 221                     fieldLabel: gettext('Decompression algorithm'),
 222                     allowBlank: true,
 223                     hasNoneOption: true,
 224                     deleteEmpty: false,
 225                     value: '__default__',
 226                     comboItems: [
 227                                 ['__default__', Proxmox.Utils.NoneText],
 228                                 ['lzo', 'LZO'],
 229                                 ['gz', 'GZIP'],
 230                                 ['zst', 'ZSTD'],
 231                     ],
 232                     cbind: {
 233                         hidden: get => get('content') !== 'iso',
 234                     },
 235                 },
 236             ],
 237         },
 238         {
 239             xtype: 'hiddenfield',
 240             name: 'content',
 241             cbind: {
 242                 value: '{content}',
 243             },
 244         },
 245     ],
 246
 247     initComponent: function() {
 248         var me = this;
 249
 250         if (!me.nodename) {
 251             throw "no node name specified";
 252         }
 253         if (!me.storage) {
 254             throw "no storage ID specified";
 255         }
 256         me.callParent();
 257     },
 258 });
 259