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

   1 define([
   2     'app/yangman/models/historylist.model',
   3     'app/yangman/models/collectionlist.model',
   4     'app/yangman/models/history-request.model',
   5 ], function (HistoryListModel, CollectionListModel, HistoryRequestModel) {
   6     'use strict';
   7
   8     angular.module('app.yangman').service('RequestsService', RequestsService);
   9
  10     RequestsService.$inject = ['$filter', 'PathUtilsService', 'ParametersService', 'ParsingJsonService', 'YangUtilsService'];
  11
  12     function RequestsService($filter, PathUtilsService, ParametersService, ParsingJsonService, YangUtilsService){
  13
  14         var service = {};
  15
  16         service.applyParamsToObj = applyParamsToObj;
  17         service.applyParamsToStr = applyParamsToStr;
  18         service.createEmptyCollectionList = createEmptyCollectionList;
  19         service.createEmptyHistoryList = createEmptyHistoryList;
  20         service.createHistoryRequestFromElement = createHistoryRequestFromElement;
  21         service.createHistoryRequest = createHistoryRequest;
  22         service.scanDataParams = scanDataParams;
  23         service.replaceStringInText = replaceStringInText;
  24
  25         /**
  26          * Scan used parameters in current line of codemirror
  27          * @param {ParametersListModel} paramsObj - list of parameters to be searched for
  28          * @param {string} lineString - line from current codemirror to be inspected
  29          * @returns array of {ParameterModel}
  30          */
  31         function scanDataParams(paramsObj, lineString) {
  32
  33             var usedParamLabelArray = [];
  34
  35             var params = lineString ? lineString.match(/<<(?!<<)[a-zA-Z0-9]+>>/g) : null;
  36
  37             if ( params ) {
  38                 params
  39                     .filter(onlyUnique)
  40                     .forEach(function (param) {
  41                         usedParamLabelArray.push(removeUnwantedChars(param));
  42                     });
  43             }
  44
  45             var returnedParamsList = paramsObj.list.filter( function (param){
  46                 var paramIndex = usedParamLabelArray.indexOf(param.name);
  47
  48                 if ( paramIndex !== -1 ) {
  49                     return usedParamLabelArray.splice(paramIndex, 1);
  50                 }
  51                 else {
  52                     return false;
  53                 }
  54             });
  55
  56             usedParamLabelArray.forEach(function (param){
  57                 returnedParamsList.push(ParametersService.createParameter({ name: param }));
  58             });
  59
  60             return returnedParamsList;
  61
  62             /**
  63              * remove chars greater then and less then from parameter definition
  64              * @param val
  65              * @returns {string}
  66              */
  67             function removeUnwantedChars(val){
  68                 var string = val.substring(2);
  69                 return string.substring(0, string.indexOf('>>'));
  70             }
  71
  72             /**
  73              * Filter function
  74              * @param value
  75              * @param index
  76              * @param self
  77              * @returns {boolean}
  78              */
  79             function onlyUnique(value, index, self) {
  80                 return self.indexOf(value) === index;
  81             }
  82         }
  83
  84         /**
  85          * Replace all parameters with its values
  86          * @param paramsObj
  87              * @param str
  88          * @returns {*}
  89          */
  90         function applyParamsToStr(paramsObj, str) {
  91             if (paramsObj && paramsObj.hasOwnProperty('list')) {
  92                 paramsObj.list.forEach(function (param){
  93                     str = service.replaceStringInText(str, '<<' + param.name + '>>', param.value);
  94                 });
  95             }
  96
  97             return str;
  98         }
  99
 100         /**
 101          * Replace all parameters with its values
 102          * @param paramsObj
 103          * @param requestData
 104          * @returns {*}
 105          */
 106         function applyParamsToObj(paramsObj, data) {
 107             var dataStr = JSON.stringify(data);
 108
 109             dataStr = service.applyParamsToStr(paramsObj, dataStr);
 110
 111             return ParsingJsonService.parseJson(dataStr);
 112         }
 113
 114         /**
 115          * Service for replacing string in text
 116          * @param text
 117          * @param strToReplace
 118          * @param newStr
 119          * @returns {*}
 120          */
 121         function replaceStringInText(text, strToReplace, newStr) {
 122             var replacedText = text;
 123             if (text.indexOf(strToReplace) > -1) {
 124                 replacedText = text.split(strToReplace).join(newStr);
 125             }
 126             return replacedText;
 127         }
 128
 129         /**
 130          * Service for creating basic history object
 131          * @param sentData
 132          * @param receivedData
 133          * @param path
 134          * @param operation
 135          * @param status
 136          * @param name
 137          * @param collection
 138          * @returns {*}
 139          * @param timestamp
 140          */
 141         function createHistoryRequest(sentData, receivedData, path, operation, status, name, collection, timestamp,
 142                         responseStatus, responseStatusText, responseTime) {
 143             // TODO: investigate, if this line is needed
 144             // var receivedDataProcessed = status === 'success' ? receivedData : null,
 145             var result = new HistoryRequestModel(PathUtilsService, YangUtilsService, ParsingJsonService);
 146
 147             timestamp = timestamp || Date.now();
 148
 149             result.setData(sentData, receivedData, status, path, operation, name, collection, timestamp,
 150                 responseStatus, responseStatusText, responseTime);
 151
 152             return result;
 153         }
 154
 155         /**
 156          * Creating {HistoryRequest} from elem containing all necessary data
 157          * @param {Object} elem
 158          * @returns {*}
 159          */
 160         function createHistoryRequestFromElement(elem) {
 161             if (!elem.hasOwnProperty('timestamp') || elem.timestamp === ''){
 162                 elem.timestamp = Date.now();
 163             }
 164
 165             return service.createHistoryRequest(elem.sentData, elem.receivedData, elem.path, elem.method,
 166                     elem.status, elem.name, elem.collection, elem.timestamp, elem.responseStatus,
 167                     elem.responseStatusText, elem.responseTime
 168                 );
 169         }
 170
 171         /**
 172          * Service for creating empty collection list
 173          * @param name
 174          * @param getApiFunction
 175          * @returns {CollectionList}
 176          */
 177         function createEmptyCollectionList(name){
 178             var result = new CollectionListModel(ParsingJsonService, service);
 179             result.setName(name);
 180             return result;
 181         }
 182
 183         /**
 184          * Service for creating empty history list
 185          * @param name
 186          * @returns {*}
 187          */
 188         function createEmptyHistoryList(name){
 189             var result = new HistoryListModel($filter, ParsingJsonService, service);
 190             result.setName(name);
 191             return result;
 192         }
 193
 194         return service;
 195
 196     }
 197
 198 });