skyquake/plugins/composer/src/src/sources/CatalogPackageManagerSource.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 alt from '../alt'
  22 import catalogUtils from '../libraries/utils'
  23 import CatalogPackageManagerActions from '../actions/CatalogPackageManagerActions'
  24 import Utils from 'utils/utils.js';
  25
  26 const getAuthorization = () => 'Basic ' + window.sessionStorage.getItem("auth");
  27
  28 const getStateApiPath = (operation, id) =>
  29         catalogUtils.getSearchParams(window.location).upload_server + ':4567/api/' + operation + '/' + id + '/state';
  30
  31 const getComposerApiPath = (api) =>
  32         window.location.origin + '/composer/api/' + api + '?api_server=' + catalogUtils.getSearchParams(window.location).api_server;
  33
  34 const SUCCESS = {
  35                 pending: false,
  36                 success: true,
  37                 error: false,
  38                 message: "Completely successfully"
  39         };
  40 const FAILED = {
  41                 pending: false,
  42                 success: false,
  43                 error: true,
  44                 message: "Failed"
  45         };
  46 const PENDING = {
  47                 pending: true,
  48                 success: false,
  49                 error: false,
  50                 message: "In progress"
  51         };
  52
  53 function ajaxFetch(url, operation, resolve, reject, method = 'GET', input, urlOverride) {
  54         let credentials = 'same-origin';
  55         let body = input ? JSON.stringify(input) : null;
  56         let headers = new Headers();
  57         headers.append('Authorization', getAuthorization());
  58         headers.append('Accept', 'application/json');
  59         if (input) {
  60                 headers.append('Content-Type', 'application/json');
  61         }
  62
  63         fetch(url, {method, credentials, headers, body})
  64                 .then(checkStatusGetJson)
  65                 .then(handleSuccess)
  66                 .catch(handleError);
  67
  68         function checkStatusGetJson(response) {
  69                 if (response.status >= 200 && response.status < 300) {
  70                         return response.json();
  71                 } else {
  72                         var error = new Error(response.statusText)
  73                         error.status = response.status;
  74                         error.statusText = response.statusText;
  75                         throw error
  76                 }
  77         }
  78
  79         function handleSuccess (data) {
  80                 if (typeof data == 'string') {
  81                         data = JSON.parse(data);
  82                 }
  83                 resolve({
  84                         state: operation,
  85                         data,
  86                         operation
  87                 });
  88         }
  89
  90         function handleError (data) {
  91                 if (typeof data == 'string') {
  92                         data = JSON.parse(data);
  93                 }
  94                 reject({
  95                         state: operation,
  96                         data,
  97                         operation
  98                 });
  99         }
 100 }
 101
 102 const CatalogPackageManagerSource = {
 103
 104         requestCatalogPackageDownload: function () {
 105                 return {
 106                         remote: function (state, download, format, grammar, schema) {
 107                                 return new Promise((resolve, reject) => {
 108                                         // we need an initial status for UI (server does not send)
 109                                         const setStatusBeforeResolve = (response) => {
 110                                                 response.data.status = 'download-requested';
 111                                                 resolve(response);
 112                                         };
 113                                         const data = {
 114                                                 "package-type": download['catalogItems'][0]['uiState']['type'].toUpperCase(),
 115                                                 "package-id": download.ids,
 116                                                 "export-format": format && format.toUpperCase() || 'YAML',
 117                                                 "export-grammar": grammar && grammar.toUpperCase() || 'OSM',
 118                                                 "export-schema": schema && schema.toUpperCase() || "RIFT"
 119                                         }
 120                                         const path = getComposerApiPath('package-export');
 121                                         ajaxFetch(path, download, setStatusBeforeResolve, reject, 'POST', data, true);
 122                                 })
 123                         },
 124                         success: CatalogPackageManagerActions.downloadCatalogPackageStatusUpdated,
 125                         error: CatalogPackageManagerActions.downloadCatalogPackageError
 126                 };
 127         },
 128
 129         requestCatalogPackageDownloadStatus: function() {
 130                 return {
 131                         remote: function(state, download) {
 132                                 const transactionId = download.transactionId;
 133                                 return new Promise(function(resolve, reject) {
 134                                         const path = getStateApiPath('export', transactionId);
 135                                         ajaxFetch(path, download, resolve, reject);
 136                                 });
 137                         },
 138                         success: CatalogPackageManagerActions.downloadCatalogPackageStatusUpdated,
 139                         error: CatalogPackageManagerActions.downloadCatalogPackageError
 140                 }
 141         },
 142
 143         requestCatalogPackageCopy: function () {
 144                 return {
 145                         remote: function (state, operationInfo) {
 146                                 return new Promise((resolve, reject) => {
 147                                         // we need an initial status for UI (server does not send)
 148                                         const successHandler = (response) => {
 149                                                 const status = response.data.output.status;
 150                                                 const state = status === "COMPLETED" ? SUCCESS : status === "FAILED" ? FAILED : PENDING;
 151                                                 state.progress = 25; // put something
 152                                                 let operation = Object.assign({}, operationInfo, state);
 153                                                 operation.transactionId = response.data.output['transaction-id'];
 154                                                 resolve(operation);
 155                                         }
 156                                         const failHandler = (response) => {
 157                                                 let operation = Object.assign({}, this, FAILED);
 158                                                 reject(operation);
 159                                         };
 160                                         const data = {
 161                                                 "package-type": operationInfo.packageType,
 162                                                 "package-id": operationInfo.id,
 163                                                 "package-name": operationInfo.name
 164                                         }
 165                                         const path = getComposerApiPath('package-copy');
 166                                         ajaxFetch(path, operationInfo, successHandler, failHandler, 'POST', data, true);
 167                                 })
 168                         },
 169                         success: CatalogPackageManagerActions.updateStatus,
 170                         error: CatalogPackageManagerActions.updateStatus
 171                 };
 172         },
 173
 174         requestCatalogPackageCopyStatus: function() {
 175                 return {
 176                         remote: function(state, operation) {
 177                                 return new Promise(function(resolve, reject) {
 178                                         const successHandler = (response) => {
 179                                                 const status = response.data[0].status;
 180                                                 const state = status === "COMPLETED" ? SUCCESS : status === "FAILED" ? FAILED : PENDING;
 181                                                 state.progress = state.pending ? operation.progress + ((100 - operation.progress) / 2) : 100;
 182                                                 let newOp = Object.assign({}, operation, state);
 183                                                 resolve(newOp);
 184                                         };
 185                                         const failHandler = (response) => {
 186                                                 let operation = Object.assign({}, this, FAILED);
 187                                                 reject(operation);
 188                                         };
 189                                         const path = getComposerApiPath('package-manager/jobs/' + operation.transactionId);
 190                                         ajaxFetch(path, operation, successHandler, failHandler);
 191                                 });
 192                         },
 193                         success: CatalogPackageManagerActions.updateStatus,
 194                         error: CatalogPackageManagerActions.updateStatus
 195                 }
 196         },
 197
 198         requestCatalogPackageUploadStatus: function () {
 199                 return {
 200                         remote: function (state, upload) {
 201                                 const transactionId = upload.transactionId;
 202                                 return new Promise(function (resolve, reject) {
 203                                         const action = upload.riftAction === 'onboard' ? 'upload' : 'update';
 204                                         const path = getStateApiPath(action, transactionId);
 205                                         ajaxFetch(path, upload, resolve, reject);
 206                                 });
 207                         },
 208                         success: CatalogPackageManagerActions.uploadCatalogPackageStatusUpdated,
 209                         error: CatalogPackageManagerActions.uploadCatalogPackageError
 210                 };
 211         }
 212
 213 };
 214
 215 export default CatalogPackageManagerSource;