modules/common-yangutils-resources/src/main/resources/yangutils/services/filter-node-wrapper.services.js

   1 define([], function () {
   2     'use strict';
   3
   4     function FilterNodeWrapperService(constants){
   5
   6         var service = {
   7             init: init,
   8             wrapForFilter: wrapForFilter,
   9         };
  10
  11         return service;
  12
  13         // TODO: add service's description
  14         function init(node){
  15
  16             node.childrenFilterConditions = function (children){
  17                 var allowedNodeTypesForFilter = constants.ALLOWED_NODE_TYPES_FOR_FILTER,
  18                     conditionTypes = function (item){
  19                         return allowedNodeTypesForFilter.some(function (elem){
  20                             return elem === item.type;
  21                         }); },
  22                     conditionEmptyChildren = function (item){
  23                         return item.children.some(function (child){
  24                             return (child.type !== 'leaf-list' && child.type !== 'list');
  25                         }); },
  26                     conditionChildDescription = function (item){
  27                         return !(item.children.every(function (childDes){
  28                             return childDes.type === 'description';
  29                         })); };
  30
  31                 return children.filter(function (item){
  32                     if (item.parent.type === 'leaf' || item.parent.parent.type === 'leaf'){
  33                         return true;
  34                     } else {
  35                         return conditionTypes(item) && conditionEmptyChildren(item) && conditionChildDescription(item);
  36                     }
  37                 });
  38             };
  39
  40             node.getChildrenForFilter = function () {
  41                 return node.childrenFilterConditions(node.getChildren(null, null, constants.NODE_UI_DISPLAY, null));
  42             };
  43
  44             node.deepCopyForFilter = function (additionalProperties) {
  45                 var copy = node.getCleanCopy(),
  46                     self = this,
  47                     allowedLeafTypesForFilter = constants.ALLOWED_LEAF_TYPES_FOR_FILTER,
  48
  49                     addFilterProps = function (childrenArray){
  50                         if (childrenArray.type === 'leaf' && childrenArray.children && childrenArray.children.length){
  51                             if (childrenArray.children.some(function (item){
  52                                 return item.type === 'type' && allowedLeafTypesForFilter.indexOf(item.label) !== -1;
  53                             })){
  54                                 childrenArray.filterType = '=';
  55                             }
  56                             if (childrenArray.children.some(function (item){
  57                                 return item.type === 'type' && item.label === 'bits';
  58                             })){
  59                                 childrenArray.filterBitsValue = '';
  60                             }
  61                             if (childrenArray.children.some(function (item){
  62                                 return item.type === 'type' && item.label === 'enumeration';
  63                             })){
  64                                 childrenArray.filterSelectboxBitsValue = [];
  65                             }
  66                         }
  67                     };
  68
  69                 additionalProperties = additionalProperties || ['pathString'];
  70
  71                 additionalProperties.forEach(function (prop) {
  72                     if (prop !== 'children' && self.hasOwnProperty(prop) && copy.hasOwnProperty(prop) === false) {
  73                         copy[prop] = self[prop];
  74                     }
  75                 });
  76
  77                 this.childrenFilterConditions(this.children).forEach(function (child) {
  78                     var childCopy = null;
  79                     if (child.type === 'leaf'){
  80                         childCopy = child.deepCopy();
  81                     } else {
  82                         init(child);
  83                         childCopy = child.deepCopyForFilter();
  84                     }
  85
  86                     childCopy.parent = copy;
  87
  88                     addFilterProps(childCopy);
  89
  90                     copy.children.push(childCopy);
  91                 });
  92
  93                 addFilterProps(copy);
  94
  95                 return copy;
  96             };
  97         }
  98
  99         // TODO: add service's description
 100         function wrapForFilter(node) {
 101             var comparePropToElemByName = function (propName, elemName) {
 102                     // TODO: also check by namespace - redundancy?
 103                     return (propName.indexOf(':') > -1 ? propName.split(':')[1] : propName) === elemName;
 104                 },
 105
 106                 wrapperFilter = {
 107
 108                     wrapFilter: function (node) {
 109                         if (this.hasOwnProperty(node.type)) {
 110                             this[node.type](node);
 111                         }
 112                     },
 113
 114                     wrapAllFilter: function (node) {
 115                         var self = this;
 116                         self.wrapFilter(node);
 117                         node.children.forEach(function (child) {
 118                             self.wrapAllFilter(child);
 119                         });
 120                     },
 121
 122                     leaf: function (node) {
 123                         var auxBuildRequest = node.buildRequest,
 124                             auxFill = node.fill,
 125                             auxClear = node.clear,
 126                             fnToString = function (string) {
 127                                 var valueStr = '';
 128                                 try {
 129                                     valueStr = string.toString();
 130                                 } catch (e) {
 131                                     console.warn('cannot convert value', node.value);
 132                                 }
 133                                 return valueStr;
 134                             };
 135
 136                         node.expandedBits = false;
 137
 138                         node.filterRangeFrom = '';
 139                         node.filterRangeTo = '';
 140
 141                         node.buildRequest = function (builder, req) {
 142                             auxBuildRequest(builder, req);
 143                             var valueStr = '';
 144                             valueStr = fnToString(node.value);
 145
 146                             var filterTypeArray = {
 147                                 '=': function (element, filterValue, i){
 148                                     return element ? element[i] === filterValue : false;
 149                                 },
 150                                 '>': function (element, filterValue, i){
 151                                     return element ? element[i] > filterValue : false;
 152                                 },
 153                                 '>=': function (element, filterValue, i){
 154                                     return element ? element[i] >= filterValue : false;
 155                                 },
 156                                 '<': function (element, filterValue, i){
 157                                     return element ? element[i] < filterValue : false;
 158                                 },
 159                                 '<=': function (element, filterValue, i){
 160                                     return element ? element[i] <= filterValue : false;
 161                                 },
 162                                 'contains': function (element, filterValue, i){
 163                                     return  element ? element[i] && element[i].indexOf(filterValue) > -1 : false;
 164                                 },
 165                                 'regExp': function (element, filterValue, i){
 166                                     var testRegExp = function (patternString, nodeValue) {
 167                                         var pattern = new RegExp(patternString);
 168                                         return pattern.test(nodeValue);
 169                                     };
 170                                     return  element ? testRegExp(filterValue, element[i]) : false;
 171                                 },
 172                                 'range': function (element, from, to, i){
 173                                     if (from && to){
 174                                         return element ? element[i] <= to && element[i] >= from : false;
 175                                     } else if (from){
 176                                         return element ? element[i] >= from : false;
 177                                     } else {
 178                                         return element ? element[i] <= to : false;
 179                                     }
 180                                 } };
 181
 182                             if (valueStr || (node.filterBitsValue && node.filterBitsValue !== '') ||
 183                                 (node.filterSelectboxBitsValue && node.filterSelectboxBitsValue.length) ||
 184                                 (node.filterRangeFrom && node.filterRangeFrom !==  '') ||
 185                                 (node.filterRangeTo && node.filterRangeTo !==  '')){
 186
 187                                 var reqFilter = {};
 188
 189                                 if (node.filterSelectboxBitsValue && node.filterSelectboxBitsValue.length){
 190                                     reqFilter.selectboxBitsValue = node.filterSelectboxBitsValue;
 191                                     reqFilter.getResult = function (element, filterValue, i){
 192                                         var selectSomeFun = function (filterSelectboxBitsValue, el){
 193                                             return filterSelectboxBitsValue.some(function (item){
 194                                                 return item === el;
 195                                             });
 196                                         };
 197                                         return element[i] && selectSomeFun(filterValue, element[i]);
 198                                     };
 199                                 } else {
 200                                     if (node.filterBitsValue && node.filterBitsValue !== ''){
 201                                         reqFilter.bitsValue = node.filterBitsValue;
 202                                     } else {
 203                                         reqFilter.value = valueStr;
 204                                     }
 205
 206                                     if (node.filterType){
 207                                         reqFilter.filterType = node.filterType;
 208                                     } else {
 209                                         reqFilter.filterType = '=';
 210                                     }
 211
 212                                     if (node.filterRangeFrom){
 213                                         reqFilter.filterRangeFrom = node.filterRangeFrom;
 214                                     }
 215
 216                                     if (node.filterRangeTo){
 217                                         reqFilter.filterRangeTo = node.filterRangeTo;
 218                                     }
 219
 220                                     reqFilter.getFilterResult = filterTypeArray;
 221                                 }
 222
 223                                 builder.insertPropertyToObj(req, node.label, reqFilter);
 224
 225                                 return true;
 226                             }
 227                             return false;
 228                         };
 229
 230                         node.fill = function (name, data) {
 231                             if (data){
 232                                 if (data.hasOwnProperty('value')){
 233                                     auxFill(name, data.value);
 234                                 }
 235                                 var match = '';
 236
 237                                 if (data.hasOwnProperty('filterType')){
 238                                     match = comparePropToElemByName(name, node.label);
 239                                     if (match){
 240                                         node.filterType = data.filterType;
 241                                     }
 242                                 }
 243                                 if (data.hasOwnProperty('bitsValue')){
 244                                     match = comparePropToElemByName(name, node.label);
 245                                     if (match){
 246                                         node.filterBitsValue = data.bitsValue;
 247                                     }
 248                                 }
 249                                 if (data.hasOwnProperty('selectboxBitsValue')){
 250                                     match = comparePropToElemByName(name, node.label);
 251                                     if (match){
 252                                         node.filterSelectboxBitsValue = data.selectboxBitsValue;
 253                                     }
 254                                 }
 255                                 if (data.hasOwnProperty('filterRangeFrom')){
 256                                     match = comparePropToElemByName(name, node.label);
 257                                     if (match){
 258                                         node.filterRangeFrom = data.filterRangeFrom;
 259                                     }
 260                                 }
 261                                 if (data.hasOwnProperty('filterRangeTo')){
 262                                     match = comparePropToElemByName(name, node.label);
 263                                     if (match){
 264                                         node.filterRangeTo = data.filterRangeTo;
 265                                     }
 266                                 }
 267                             } else {
 268                                 console.error('fill data are empty');
 269                             }
 270                         };
 271
 272                         node.clear = function () {
 273                             auxClear();
 274                             node.value = '';
 275
 276                             if (node.filterType){
 277                                 node.filterType = '=';
 278                             }
 279                             if (node.filterBitsValue){
 280                                 node.filterBitsValue = '';
 281                             }
 282                             if (node.filterSelectboxBitsValue){
 283                                 node.filterSelectboxBitsValue = [];
 284                             }
 285                             if (node.filterRangeFrom){
 286                                 node.filterRangeFrom = '';
 287                             }
 288                             if (node.filterRangeTo){
 289                                 node.filterRangeTo = '';
 290                             }
 291                         };
 292
 293                     },
 294
 295                     type: function (node) {
 296                     },
 297
 298                     length: function (node) {
 299                     },
 300
 301                     range: function (node) {
 302                     },
 303
 304                     pattern: function (node) {
 305                     },
 306
 307                     container: function (node) {
 308                     },
 309
 310                     rpc: function (node) {
 311                     },
 312
 313                     input: function (node) {
 314                     },
 315
 316                     output: function (node) {
 317                     },
 318
 319                     case: function (node) {
 320                     },
 321
 322                     choice: function (node) {
 323                     },
 324
 325                     'leaf-list': function (node) {
 326                     },
 327
 328                     key: function (node) {
 329                     },
 330
 331                     list: function (node) {
 332
 333                     },
 334
 335                     _listElem: function (node) {
 336                     },
 337                 };
 338
 339             wrapperFilter.wrapAllFilter(node);
 340         }
 341     }
 342
 343     FilterNodeWrapperService.$inject = ['constants'];
 344
 345     return FilterNodeWrapperService;
 346
 347 });