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