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

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