skyquake/plugins/composer/src/src/components/filemanager/FileManagerSource.js

   1
   2 /*
   3  *
   4  *   Copyright 2016 RIFT.IO Inc
   5  *
   6  *   Licensed under the Apache License, Version 2.0 (the "License");
   7  *   you may not use this file except in compliance with the License.
   8  *   You may obtain a copy of the License at
   9  *
  10  *       http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *   Unless required by applicable law or agreed to in writing, software
  13  *   distributed under the License is distributed on an "AS IS" BASIS,
  14  *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *   See the License for the specific language governing permissions and
  16  *   limitations under the License.
  17  *
  18  */
  19 'use strict';
  20
  21 import $ from 'jquery'
  22 import alt from '../../alt'
  23 import utils from '../../libraries/utils'
  24 import FileManagerActions from './FileManagerActions'
  25 let Utils = require('utils/utils.js');
  26 let API_SERVER = require('utils/rw.js').getSearchParams(window.location).api_server;
  27 let HOST = API_SERVER;
  28 let NODE_PORT = require('utils/rw.js').getSearchParams(window.location).api_port || ((window.location.protocol == 'https:') ? 8443 : 8000);
  29 const FileManagerSource = {
  30
  31     getFilelist: function() {
  32         return {
  33             remote: function(state, id, type) {
  34                 return new Promise(function(resolve, reject) {
  35                     console.log('Getting File Manager');
  36                     $.ajax({
  37                         beforeSend: Utils.addAuthorizationStub,
  38                         url: 'api/file-manager?api_server=' + utils.getSearchParams(window.location).api_server +'&package_type=' + type + '&package_id=' + id,
  39                         success: function(data) {
  40                             resolve(JSON.parse(data));
  41                         },
  42                         error: function(error) {
  43                             if (typeof error == 'string') {
  44                                 error = JSON.parse(error);
  45                             }
  46                             reject(error);
  47                         }
  48                     }).fail(function(xhr){
  49                         //Authentication and the handling of fail states should be wrapped up into a connection class.
  50                         Utils.checkAuthentication(xhr.status);
  51                     });
  52                 });
  53             },
  54             success: FileManagerActions.getFilelistSuccess,
  55             error: FileManagerActions.getFilelistError
  56         }
  57     },
  58     addFile: function() {
  59         return {
  60             remote: function(state, id, type, path, url, refresh) {
  61                 return new Promise(function(resolve, reject) {
  62                     console.log('Adding file');
  63                     console.log(id, type, path, url);
  64                     let splitUrl = url.split('/');
  65                     let fileName = splitUrl[splitUrl.length -1];
  66                     let packagePath = refresh ? path + ((path[path.length - 1] == '/') ? '' : '/') : path + '/' + fileName;
  67                     $.ajax({
  68                         beforeSend: Utils.addAuthorizationStub,
  69                         url: 'api/file-manager?api_server=' + utils.getSearchParams(window.location).api_server +'&package_type=' + type + '&package_id=' + id + '&package_path=' + packagePath + '&url=' + url,
  70                         success: function(data) {
  71                             resolve({
  72                                 data:data,
  73                                 path: path,
  74                                 fileName: fileName,
  75                                 refresh: refresh
  76                             });
  77                         },
  78                         error: function(error) {
  79                             if (typeof error == 'string') {
  80                                 error = JSON.parse(error);
  81                             }
  82                             reject(error);
  83                         }
  84                     }).fail(function(xhr){
  85                         //Authentication and the handling of fail states should be wrapped up into a connection class.
  86                         Utils.checkAuthentication(xhr.status);
  87                     });
  88                 });
  89             },
  90             success: FileManagerActions.addFileSuccess,
  91             error: FileManagerActions.addFileError
  92         }
  93     },
  94     deleteFile: function() {
  95         return {
  96             remote: function(state, id, type, path) {
  97                 return new Promise(function(resolve, reject) {
  98                     $.ajax({
  99                         method: 'DELETE',
 100                         beforeSend: Utils.addAuthorizationStub,
 101                         url: 'api/file-manager?api_server=' + utils.getSearchParams(window.location).api_server +'&package_type=' + type + '&package_id=' + id + '&package_path=' + path ,
 102                         success: function(data) {
 103                             resolve({
 104                                 data: data,
 105                                 path: path
 106                             });
 107                         },
 108                         error: function(error) {
 109                             if (typeof error == 'string') {
 110                                 error = JSON.parse(error);
 111                             }
 112                             reject(error);
 113                         }
 114                     }).fail(function(xhr){
 115                         //Authentication and the handling of fail states should be wrapped up into a connection class.
 116                         Utils.checkAuthentication(xhr.status);
 117                     });
 118                 });
 119             },
 120             success: FileManagerActions.deleteFileSuccess,
 121             error: FileManagerActions.deleteFileError
 122         }
 123     },
 124     updateFile: function() {
 125         return {
 126             remote: function(state, file) {
 127                 return new Promise(function(resolve, reject) {
 128                     console.log('Getting File Manager');
 129                     if(file) {
 130                         console.log('Updating single file');
 131                     }
 132                     if(!file) {
 133                         console.log('Update all files')
 134                     }
 135                     resolve({});
 136                 });
 137             },
 138             success: FileManagerActions.getFilelistSuccess,
 139             error: FileManagerActions.getFilelistError
 140         }
 141     },
 142     openDownloadMonitoringSocket: function() {
 143         return {
 144             remote: function(state, packageID) {
 145                 return new Promise(function(resolve, reject) {
 146                     //api/operational/download-jobs/job/
 147                    $.ajax({
 148                     url: '/socket-polling',
 149                     type: 'POST',
 150                     beforeSend: Utils.addAuthorizationStub,
 151                     data: {
 152                       url: 'composer/api/file-manager/jobs/' + packageID + '?api_server=' + API_SERVER,
 153                     },
 154                     success: function(data, textStatus, jqXHR) {
 155                         Utils.checkAndResolveSocketRequest(data, resolve, reject);
 156                     }
 157                   }).fail(function(xhr){
 158                     //Authentication and the handling of fail states should be wrapped up into a connection class.
 159                     Utils.checkAuthentication(xhr.status);
 160                   });
 161                 });
 162             },
 163             success: FileManagerActions.openDownloadMonitoringSocketSuccess,
 164             error: FileManagerActions.openDownloadMonitoringSocketError
 165         }
 166     },
 167     openFileMonitoringSocket: function() {
 168         return {
 169             remote: function(state, id, type) {
 170                 return new Promise(function(resolve, reject) {
 171                     //api/operational/download-jobs/job/
 172                    $.ajax({
 173                     url: '/socket-polling',
 174                     type: 'POST',
 175                     beforeSend: Utils.addAuthorizationStub,
 176                     data: {
 177                       url: 'composer/api/file-manager?api_server=' + utils.getSearchParams(window.location).api_server +'&package_type=' + type + '&package_id=' + id
 178                     },
 179                     success: function(data, textStatus, jqXHR) {
 180                         Utils.checkAndResolveSocketRequest(data, resolve, reject);
 181                     }
 182                   }).fail(function(xhr){
 183                     //Authentication and the handling of fail states should be wrapped up into a connection class.
 184                     Utils.checkAuthentication(xhr.status);
 185                   });
 186                 });
 187             },
 188             success: FileManagerActions.getFilelistSocketSuccess,
 189             error: FileManagerActions.getFilelistError
 190         }
 191     }
 192 };
 193
 194 export default FileManagerSource;