modules/yangman-resources/src/main/resources/yangman/services/yangman.services.js

   1 define([], function () {
   2     'use strict';
   3
   4     angular.module('app.yangman').service('YangmanService', YangmanService);
   5
   6     YangmanService.$inject = [
   7         'RequestBuilderService',
   8         'YangUtilsService',
   9         'YangUtilsRestangularService',
  10         'ENV',
  11         'ParsingJsonService',
  12         'RequestsService',
  13
  14     ];
  15
  16     function YangmanService(
  17         RequestBuilderService,
  18         YangUtilsService,
  19         YangUtilsRestangularService,
  20         ENV,
  21         ParsingJsonService,
  22         RequestsService
  23     ){
  24         var service = {
  25             executeRequestOperation: executeRequestOperation,
  26             fillNodeFromResponse: fillNodeFromResponse,
  27             getDataStoreIndex: getDataStoreIndex,
  28             prepareAllRequestData: prepareAllRequestData,
  29             validateFile: validateFile,
  30         };
  31
  32         return service;
  33
  34         /**
  35          * Validating collection import file
  36          * @param data
  37          * @param checkArray
  38          * @returns {*}
  39          */
  40         function validateFile(data, checkArray){
  41             try {
  42                 var obj = ParsingJsonService.parseJson(data);
  43
  44                 return obj && obj.every(function (el){
  45                     return checkArray.every(function (arr){
  46                         return el.hasOwnProperty(arr);
  47                     });
  48                 });
  49             } catch (e) {
  50                 return e;
  51             }
  52         }
  53
  54         /**
  55          * Return index of selected datastore in list
  56          * @param list
  57          * @param dataStore
  58          * @returns {*}
  59          */
  60         function getDataStoreIndex(list, dataStore){
  61             var rIndex = null,
  62                 result = list.some(function (item, index) {
  63                     rIndex = index;
  64                     return item.label === dataStore;
  65                 });
  66
  67             return result ? rIndex : null;
  68         }
  69
  70         /**
  71          * Prepare all necessary data for executing or saving request
  72          * @param selectedApi
  73          * @param selectedSubApi
  74          * @param operation
  75          * @param node
  76          * @param dataType
  77          * @param requestUrl
  78          * @param requestData
  79          * @param params
  80          * @returns {{customRestangular: null, headers: {}, operation: string, reqString: string, reqHeaders: {},
  81          *          reqData: {}}}
  82          */
  83         function prepareAllRequestData(selectedApi, selectedSubApi, operation, node, dataType, requestUrl, requestData,
  84                                        params) {
  85             var allPreparedData = {
  86                 customRestangular: null,
  87                 headers: {},
  88                 operation: '',
  89                 reqString: selectedSubApi ? selectedSubApi.buildApiRequestString() : '',
  90                 reqHeaders: {},
  91                 reqData: '',
  92                 srcData: '',
  93             };
  94
  95             if ( dataType === 'form' && node){
  96                 node.buildRequest(RequestBuilderService, requestData, node.module);
  97                 allPreparedData.srcData = angular.copy(requestData);
  98             }
  99             else {
 100                 allPreparedData.srcData = requestData;
 101             }
 102             allPreparedData.reqData = RequestsService.applyParams(params, allPreparedData.srcData);
 103
 104             // prepare req data
 105             if (operation === 'GET' || operation === 'DELETE'){
 106                 allPreparedData.srcData = null;
 107                 allPreparedData.reqData = null;
 108             }
 109             else if (operation === 'POST'){
 110                 allPreparedData.reqData = YangUtilsService.postRequestData(
 111                     allPreparedData.reqData,
 112                     allPreparedData.reqString,
 113                     selectedSubApi
 114                 );
 115             }
 116
 117             // set correct host into restangular based on shown data type and prepare data
 118             if ( dataType === 'req-data' ){
 119                 var parser = locationHelper(requestUrl, ['pathname', 'origin']),
 120                     raParam = '';
 121
 122                 YangUtilsRestangularService.setBaseUrl(parser.origin);
 123                 allPreparedData.reqString = parser.pathname.slice(1).split('/');
 124                 raParam = allPreparedData.reqString.shift();
 125                 allPreparedData.reqString = allPreparedData.reqString.join('/');
 126
 127                 allPreparedData.customRestangular = YangUtilsRestangularService.one(raParam);
 128
 129             } else {
 130
 131                 YangUtilsRestangularService.setBaseUrl(ENV.getBaseURL('MD_SAL'));
 132                 allPreparedData.customRestangular  = YangUtilsRestangularService.one('restconf');
 133
 134                 if ( node ) {
 135                     allPreparedData.headers = YangUtilsService.prepareHeaders(allPreparedData.reqData);
 136                 }
 137             }
 138
 139             allPreparedData.operation = YangUtilsService.prepareOperation(operation);
 140             return allPreparedData;
 141         }
 142
 143         /**
 144          * Execute request built from this data
 145          * @param selectedApi
 146          * @param selectedSubApi
 147          * @param operation
 148          * @param node
 149          * @param dataType
 150          * @param requestUrl
 151          * @param requestData
 152          * @param successCbk
 153          * @param errorCbk
 154          * @param params
 155          */
 156         function executeRequestOperation(selectedApi, selectedSubApi, operation, node, dataType, requestUrl,
 157                                          requestData, params, successCbk, errorCbk) {
 158             var time = {
 159                 started: 0,
 160                 finished: 0,
 161             };
 162
 163             YangUtilsRestangularService.setFullResponse(true);
 164
 165             // prepare all necessary data
 166             var allPreparedData = prepareAllRequestData(selectedApi, selectedSubApi, operation, node, dataType,
 167                 requestUrl, requestData, params);
 168
 169             // start track time response
 170             time.started = new Date().getMilliseconds();
 171
 172             // executing operation
 173             allPreparedData.customRestangular.customOperation(
 174                 allPreparedData.operation.toLowerCase(),
 175                 allPreparedData.reqString,
 176                 null,
 177                 allPreparedData.headers,
 178                 allPreparedData.reqData
 179             )
 180             .then(
 181                 function (response) {
 182                     (successCbk || angular.noop)(finishExecuting(response), response);
 183                 },
 184                 function (response) {
 185                     (errorCbk || angular.noop)(finishExecuting(response), response);
 186                 }
 187             );
 188
 189             function finishExecuting(response){
 190                 // finish track time response
 191                 time.finished = new Date().getMilliseconds();
 192
 193                 return {
 194                     status: response.status,
 195                     statusText: response.statusText,
 196                     time: (time.finished - time.started),
 197                     requestData: allPreparedData.reqData,
 198                     requestSrcData: allPreparedData.srcData,
 199                 };
 200             }
 201         }
 202
 203         /**
 204          * Method for parsing path to additional properties based on JS LOCATION
 205          * @param path
 206          * @param properties
 207          * @returns {{}}
 208          */
 209         function locationHelper(path, properties){
 210             var parser = document.createElement('a'),
 211                 obj = {};
 212
 213             parser.href = path;
 214
 215             properties.forEach(function (prop) {
 216                 obj[prop] = parser[prop];
 217             });
 218
 219             return obj;
 220         }
 221
 222         /**
 223          * Fill node values from response
 224          * @param node
 225          * @param data
 226          */
 227         function fillNodeFromResponse(node, data){
 228             var props = data ? Object.getOwnPropertyNames(data) : [];
 229
 230             // fill each property - needed for root mountpoint node,
 231             // in other cases there should be only one property anyway
 232             props.forEach(function (p) {
 233                 node.fill(p, data[p]);
 234             });
 235         }
 236     }
 237
 238 });