openecomp-ui/src/nfvo-utils/RestAPIUtil.js

   1 /*
   2 * Copyright © 2018 European Support Limited
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 *      http: //www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 import uuid from 'uuid-js';
  18 import md5 from 'md5';
  19 import axios from 'axios';
  20
  21 import store from 'sdc-app/AppStore.js';
  22 import { actionTypes as LoaderConstants } from 'nfvo-components/loader/LoaderConstants.js';
  23 import Configuration from 'sdc-app/config/Configuration.js';
  24 import errorResponseHandler from './ErrorResponseHandler.js';
  25
  26 //methods
  27 const GET = 'GET';
  28 const POST = 'POST';
  29 const PUT = 'PUT';
  30 const DELETE = 'DELETE';
  31 const BINARY = 'binary';
  32
  33 const AUTHORIZATION_HEADER = 'X-AUTH-TOKEN';
  34 const STORAGE_AUTH_KEY = 'sdc-auth-token';
  35 const REQUEST_ID_HEADER = 'X-ECOMP-RequestID';
  36 const CONTENT_MD5_HEADER = 'Content-MD5';
  37
  38 export function applySecurity(options, data) {
  39     let headers = options.headers || (options.headers = {});
  40     if (options.isAnonymous) {
  41         return;
  42     }
  43
  44     let authToken = localStorage.getItem(STORAGE_AUTH_KEY);
  45     if (authToken) {
  46         headers[AUTHORIZATION_HEADER] = authToken;
  47     }
  48
  49     let catalogApiHeaders = Configuration.get('CatalogApiHeaders'),
  50         catalogUidHeader = catalogApiHeaders && catalogApiHeaders.userId;
  51     if (catalogUidHeader) {
  52         headers[catalogUidHeader.name] = catalogUidHeader.value;
  53     }
  54
  55     headers[REQUEST_ID_HEADER] = uuid.create().toString();
  56     if (options.md5) {
  57         let headers = options.headers;
  58         headers[CONTENT_MD5_HEADER] = window.btoa(
  59             md5(JSON.stringify(data)).toLowerCase()
  60         );
  61     }
  62 }
  63
  64 function handleSuccess(responseHeaders, requestHeaders) {
  65     let authToken = responseHeaders[AUTHORIZATION_HEADER];
  66     let prevToken = requestHeaders && requestHeaders[AUTHORIZATION_HEADER];
  67     if (authToken && authToken !== prevToken) {
  68         if (authToken === 'null') {
  69             localStorage.removeItem(STORAGE_AUTH_KEY);
  70         } else {
  71             localStorage.setItem(STORAGE_AUTH_KEY, authToken);
  72         }
  73     }
  74 }
  75
  76 class RestAPIUtil {
  77     handleRequest(url, type, options = {}, data = {}) {
  78         applySecurity(options, data);
  79
  80         let config = {
  81             method: type,
  82             url: url,
  83             headers: options.headers,
  84             data: data
  85         };
  86
  87         store.dispatch({ type: LoaderConstants.SEND_REQUEST, url: url });
  88         if (options.dataType === BINARY) {
  89             config.responseType = 'arraybuffer';
  90             return axios(config)
  91                 .then(result => {
  92                     store.dispatch({
  93                         type: LoaderConstants.RECEIVE_RESPONSE,
  94                         url: result.config.url
  95                     });
  96                     return {
  97                         blob: new Blob([result.data]),
  98                         headers: result.headers
  99                     };
 100                 })
 101                 .catch(error => {
 102                     store.dispatch({
 103                         type: LoaderConstants.RECEIVE_RESPONSE,
 104                         url: error.config.url
 105                     });
 106                     errorResponseHandler(error.response);
 107                 });
 108         } else {
 109             return axios(config)
 110                 .then(result => {
 111                     store.dispatch({
 112                         type: LoaderConstants.RECEIVE_RESPONSE,
 113                         url: result.config.url
 114                     });
 115                     handleSuccess(result.headers, result.config.headers);
 116                     return result.data;
 117                 })
 118                 .catch(error => {
 119                     store.dispatch({
 120                         type: LoaderConstants.RECEIVE_RESPONSE,
 121                         url: error.config.url
 122                     });
 123                     errorResponseHandler(error.response);
 124                     return Promise.reject({
 125                         responseJSON: error.response.data
 126                     });
 127                 });
 128         }
 129     }
 130
 131     fetch(url, options) {
 132         return this.handleRequest(url, GET, options);
 133     }
 134
 135     get(url, options) {
 136         return this.fetch(url, options);
 137     }
 138
 139     post(url, data, options) {
 140         return this.handleRequest(url, POST, options, data);
 141     }
 142
 143     put(url, data, options) {
 144         return this.handleRequest(url, PUT, options, data);
 145     }
 146
 147     destroy(url, options) {
 148         return this.handleRequest(url, DELETE, options);
 149     }
 150 }
 151
 152 const instance = new RestAPIUtil();
 153
 154 export default instance;