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 = [
  11         '$filter', 'PathUtilsService', 'ParametersService', 'ParsingJsonService', 'YangUtilsService',
  12         'RequestBuilderService', 'constants',
  13     ];
  14
  15     function RequestsService($filter, PathUtilsService, ParametersService, ParsingJsonService, YangUtilsService,
  16                              RequestBuilderService, constants) {
  17
  18         var service = {};
  19
  20         service.applyParamsToObj = applyParamsToObj;
  21         service.applyParamsToStr = applyParamsToStr;
  22         service.clearUnnecessaryProperties = clearUnnecessaryProperties;
  23         service.createEmptyCollectionList = createEmptyCollectionList;
  24         service.createEmptyHistoryList = createEmptyHistoryList;
  25         service.createHistoryRequestFromElement = createHistoryRequestFromElement;
  26         service.createHistoryRequest = createHistoryRequest;
  27         service.fillRequestByMethod = fillRequestByMethod;
  28         service.fillRequestByViewType = fillRequestByViewType;
  29         service.findIdentifierByParam = findIdentifierByParam;
  30         service.scanDataParams = scanDataParams;
  31         service.replaceStringInText = replaceStringInText;
  32
  33         /**
  34          * Clear unnecesary properties for saving to collection
  35          * @param request
  36          */
  37         function clearUnnecessaryProperties(request){
  38             request.status = '';
  39             request.responseStatus = null;
  40             request.responseStatusText = null;
  41             request.responseTime = null;
  42
  43             return request;
  44         }
  45
  46         /**
  47          * Find parametrized identifier in path array
  48          * @param params
  49          * @param pathElement
  50          * @returns {*}
  51          */
  52         function findIdentifierByParam(params, pathElement){
  53             var foundIdentifier = null;
  54
  55             if ( pathElement.hasIdentifier() ){
  56                 pathElement.identifiers.some(function (item){
  57                     return params.list.some(function (param){
  58                         var contained = item.value.indexOf('<<' + param.name + '>>') > -1;
  59
  60                         if ( contained ){
  61                             foundIdentifier = item;
  62                         }
  63
  64                         return contained;
  65                     });
  66                 });
  67             }
  68
  69             return foundIdentifier;
  70         }
  71
  72         /**
  73          * Get data for saving request depend on view type
  74          * @param node
  75          * @param viewType
  76          * @param requestData
  77          * @param dataType
  78          * @param method
  79          * @returns {*}
  80          */
  81         function fillRequestByViewType(node, viewType, requestData, dataType, method){
  82             var setDataByViewType = {
  83                 form: function () {
  84                     var data = {},
  85                         emptyObject = method === constants.OPERATION_POST && dataType.toUpperCase() === constants.REQUEST_DATA_TYPE_RECEIVED && node.type !== constants.NODE_RPC;
  86
  87                     if ( !emptyObject ) {
  88                         node.buildRequest(RequestBuilderService, data, node.module);
  89                         data = checkNodeTypeData(node, data, dataType, requestData);
  90                     }
  91
  92                     return data;
  93                 },
  94                 'req-data': function (){
  95                     return requestData ? angular.fromJson(requestData) : {};
  96                 },
  97             };
  98
  99             return setDataByViewType[viewType]();
 100
 101             /**
 102              * Exceptions based on node type
 103              * @param node
 104              * @param data
 105              * @param dataType
 106              * @param requestData
 107              * @returns {*}
 108              */
 109             function checkNodeTypeData(node, data, dataType, requestData){
 110                 var copyData = angular.copy(data),
 111                     setDataByNodeType = {
 112                         rpc: function (){
 113
 114                             if ( dataType.toUpperCase() === constants.REQUEST_DATA_TYPE_RECEIVED ) {
 115                                 copyData = requestData ? angular.fromJson(requestData) : {};
 116                             }
 117
 118                             return copyData;
 119                         },
 120                         default: function () {
 121                             return data;
 122                         },
 123                     };
 124
 125                 return (setDataByNodeType[node.type] || setDataByNodeType.default)();
 126             }
 127         }
 128
 129         /**
 130          * Fill history request data depend on selected method - saving to collection
 131          * @param requestObj
 132          * @param sentData
 133          * @param receivedData
 134          * @param method
 135          */
 136         function fillRequestByMethod(requestObj, sentData, receivedData, method, node, viewType){
 137             var setDataByMethod = {
 138                     GET: function (){
 139                         return {
 140                             sentData: {},
 141                             receivedData: receivedData.reqData ? angular.fromJson(receivedData.reqData) : {},
 142                         };
 143                     },
 144                     POST: function (){
 145                         return {
 146                             sentData: fillRequestByViewType(node, viewType, sentData.reqData, 'sent', method),
 147                             receivedData: fillRequestByViewType(
 148                                 node, viewType, receivedData.reqData, constants.REQUEST_DATA_TYPE_RECEIVED, method
 149                             ),
 150                         };
 151                     },
 152                     PUT: function (){
 153                         return {
 154                             sentData: fillRequestByViewType(node, viewType, sentData.reqData, 'sent', method),
 155                             receivedData: {},
 156                         };
 157                     },
 158                     DELETE: function (){
 159                         return {
 160                             sentData: {},
 161                             receivedData: {},
 162                         };
 163                     },
 164                 },
 165                 data = setDataByMethod[method]();
 166
 167             requestObj.setExecutionData(data.sentData, data.receivedData, '');
 168         }
 169
 170         /**
 171          * Scan used parameters in current line of codemirror
 172          * @param {ParametersListModel} paramsObj - list of parameters to be searched for
 173          * @param {string} lineString - line from current codemirror to be inspected
 174          * @returns array of {ParameterModel}
 175          */
 176         function scanDataParams(paramsObj, lineString) {
 177
 178             var usedParamLabelArray = [];
 179
 180             var params = lineString ? lineString.match(/<<(?!<<)[a-zA-Z0-9]+>>/g) : null;
 181
 182             if ( params ) {
 183                 params
 184                     .filter(onlyUnique)
 185                     .forEach(function (param) {
 186                         usedParamLabelArray.push(removeUnwantedChars(param));
 187                     });
 188             }
 189
 190             var returnedParamsList = paramsObj.list.filter( function (param){
 191                 var paramIndex = usedParamLabelArray.indexOf(param.name);
 192
 193                 if ( paramIndex !== -1 ) {
 194                     return usedParamLabelArray.splice(paramIndex, 1);
 195                 }
 196                 else {
 197                     return false;
 198                 }
 199             });
 200
 201             usedParamLabelArray.forEach(function (param){
 202                 returnedParamsList.push(ParametersService.createParameter({ name: param }));
 203             });
 204
 205             return returnedParamsList;
 206
 207             /**
 208              * remove chars greater then and less then from parameter definition
 209              * @param val
 210              * @returns {string}
 211              */
 212             function removeUnwantedChars(val){
 213                 var string = val.substring(2);
 214                 return string.substring(0, string.indexOf('>>'));
 215             }
 216
 217             /**
 218              * Filter function
 219              * @param value
 220              * @param index
 221              * @param self
 222              * @returns {boolean}
 223              */
 224             function onlyUnique(value, index, self) {
 225                 return self.indexOf(value) === index;
 226             }
 227         }
 228
 229         /**
 230          * Replace all parameters with its values
 231          * @param paramsObj
 232          * @param str
 233          * @returns {*}
 234          */
 235         function applyParamsToStr(paramsObj, str) {
 236             if (paramsObj && paramsObj.hasOwnProperty('list')) {
 237                 paramsObj.list.forEach(function (param){
 238                     str = service.replaceStringInText(str, '<<' + param.name + '>>', param.value);
 239                 });
 240             }
 241
 242             return str;
 243         }
 244
 245         /**
 246          * Replace all parameters with its values
 247          * @param paramsObj
 248          * @param requestData
 249          * @returns {*}
 250          */
 251         function applyParamsToObj(paramsObj, data) {
 252             var dataStr = JSON.stringify(data);
 253
 254             dataStr = service.applyParamsToStr(paramsObj, dataStr);
 255
 256             return ParsingJsonService.parseJson(dataStr);
 257         }
 258
 259         /**
 260          * Service for replacing string in text
 261          * @param text
 262          * @param strToReplace
 263          * @param newStr
 264          * @returns {*}
 265          */
 266         function replaceStringInText(text, strToReplace, newStr) {
 267             var replacedText = text;
 268             if (text.indexOf(strToReplace) > -1) {
 269                 replacedText = text.split(strToReplace).join(newStr);
 270             }
 271             return replacedText;
 272         }
 273
 274         /**
 275          * Service for creating basic history object
 276          * @param sentData
 277          * @param receivedData
 278          * @param path
 279          * @param operation
 280          * @param status
 281          * @param name
 282          * @param collection
 283          * @returns {*}
 284          * @param timestamp
 285          */
 286         function createHistoryRequest(sentData, receivedData, path, operation, status, name, collection, timestamp,
 287                                       responseStatus, responseStatusText, responseTime) {
 288             var result = new HistoryRequestModel(PathUtilsService, YangUtilsService, ParsingJsonService);
 289
 290             timestamp = timestamp || Date.now();
 291
 292             result.setData(sentData, receivedData, status, path, operation, name, collection, timestamp,
 293                 responseStatus, responseStatusText, responseTime);
 294
 295             return result;
 296         }
 297
 298         /**
 299          * Creating {HistoryRequest} from elem containing all necessary data
 300          * @param {Object} elem
 301          * @returns {*}
 302          */
 303         function createHistoryRequestFromElement(elem) {
 304             if (!elem.hasOwnProperty('timestamp') || elem.timestamp === ''){
 305                 elem.timestamp = Date.now();
 306             }
 307
 308             return service.createHistoryRequest(elem.sentData, elem.receivedData, elem.path, elem.method,
 309                 elem.status, elem.name, elem.collection, elem.timestamp, elem.responseStatus,
 310                 elem.responseStatusText, elem.responseTime
 311             );
 312         }
 313
 314         /**
 315          * Service for creating empty collection list
 316          * @param name
 317          * @param getApiFunction
 318          * @returns {CollectionList}
 319          */
 320         function createEmptyCollectionList(name){
 321             var result = new CollectionListModel($filter, ParsingJsonService, service);
 322             result.setName(name);
 323             return result;
 324         }
 325
 326         /**
 327          * Service for creating empty history list
 328          * @param name
 329          * @returns {*}
 330          */
 331         function createEmptyHistoryList(name){
 332             var result = new HistoryListModel($filter, ParsingJsonService, service);
 333             result.setName(name);
 334             return result;
 335         }
 336
 337         return service;
 338
 339     }
 340
 341 });