modules/common-yangutils-resources/src/main/resources/yangutils/services/list-filtering.services.js

   1 define([], function () {
   2     'use strict';
   3
   4     function ListFilteringService(FilterNodeWrapperService, RequestBuilderService){
   5         var wasFound,
   6             filterResult;
   7
   8
   9         var getNodePathInStructure = function (filterRootNode,node) {
  10                 var iterator = -1,
  11                     findNodeInStructure = function (currentParentStructure){
  12                         if(currentParentStructure.children.length && currentParentStructure.type !== 'leaf'){
  13                             if(!(currentParentStructure.children.some(function(element){ return element === node; }))){
  14                                 currentParentStructure.children.forEach(function(child,index){
  15                                     checkHasSearchedNode(child,node);
  16                                 });
  17                             }else{
  18                                 wasFound = true;
  19                             }
  20                         }
  21                     },
  22                     checkHasSearchedNode = function (currentParent) {
  23                         if(currentParent === node){
  24                             wasFound = true;
  25                         }else{
  26                             if(currentParent.actElemStructure){
  27                                 findNodeInStructure(currentParent.actElemStructure);
  28                             }else{
  29                                 findNodeInStructure(currentParent);
  30                             }
  31                         }
  32                     },
  33                     getIndexOfSearchedNode = function (parentNodeStructure) {
  34                         parentNodeStructure.children.forEach(function(elem,index){
  35                             wasFound = false;
  36                             checkHasSearchedNode(elem,node);
  37                             if(wasFound){
  38                                 node.searchedPath.push(index);
  39                             }
  40                         });
  41                         if(parentNodeStructure.children[node.searchedPath[iterator]] !== node){
  42                             getSearchedPath(parentNodeStructure.children[node.searchedPath[iterator]]);
  43                         }
  44                     },
  45                     getSearchedPath = function(parentNode){
  46                         iterator++;
  47                         if(parentNode.actElemStructure){
  48                             getIndexOfSearchedNode(parentNode.actElemStructure);
  49                         }else{
  50                             getIndexOfSearchedNode(parentNode);
  51                         }
  52                     };
  53
  54                 if(filterRootNode !== node){
  55                     getSearchedPath(filterRootNode);
  56                 }
  57             },
  58
  59             clearFilterNodes = function(node) {
  60                 node.referenceNode.filterNodes.forEach(function(filterNode){
  61                     filterNode.clear();
  62                 });
  63             },
  64
  65             loadFilterNodes = function (node) {
  66                 var fillFuc = function(fillNods, prop, filVal){
  67                     fillNods.forEach(function(filterNode){
  68                         filterNode.fill(prop, filVal[prop]);
  69                     });
  70                 };
  71
  72                 if(node.referenceNode.filters[node.currentFilter].filteredValues){
  73                     node.referenceNode.filters[node.currentFilter].filteredValues.forEach(function(item){
  74                         for (var prop in item) {
  75                             fillFuc(node.referenceNode.filterNodes, prop, item);
  76                         }
  77                     });
  78                 }
  79             },
  80
  81             getFilterResult = function(element, filterValue, node){
  82                 for (var i in filterValue){
  83                     if(!filterValue[i].hasOwnProperty('value') && !filterValue[i].hasOwnProperty('selectboxBitsValue') && !filterValue[i].hasOwnProperty('bitsValue') &&
  84                         !filterValue[i].hasOwnProperty('filterRangeFrom') && !filterValue[i].hasOwnProperty('filterRangeTo')){
  85                         getFilterResult(element[i],filterValue[i]);
  86                     }else{
  87                         if(filterValue[i].selectboxBitsValue && filterValue[i].selectboxBitsValue.length){
  88                             filterResult = filterValue[i].getResult(element,filterValue[i].selectboxBitsValue,i);
  89                         }else{
  90                             if((filterValue[i].filterRangeFrom && filterValue[i].filterRangeFrom !== '') || (filterValue[i].filterRangeTo && filterValue[i].filterRangeTo !== '')){
  91                                 filterResult = filterValue[i].getFilterResult[filterValue[i].filterType](element,filterValue[i].filterRangeFrom,filterValue[i].filterRangeTo,i);
  92                             }else if(filterValue[i].bitsValue && filterValue[i].bitsValue !== ''){
  93                                 filterResult = filterValue[i].getFilterResult[filterValue[i].filterType](element,filterValue[i].bitsValue,i);
  94                             }else {
  95                                 filterResult = filterValue[i].getFilterResult[filterValue[i].filterType](element,filterValue[i].value,i);
  96                             }
  97                         }
  98                     }
  99                 }
 100             },
 101
 102             getActElementFilter = function (node) {
 103                 var actData = [];
 104
 105                 node.actElemIndex = 0;
 106                 if(node.filteredListData && node.filteredListData.length){
 107                     actData = node.filteredListData[node.actElemIndex];
 108                 }else{
 109                     actData = node.listData[node.actElemIndex];
 110                 }
 111
 112                 node.actElemStructure.clear();
 113                 for (var prop in actData) {
 114                     node.actElemStructure.fillListElement(prop, actData[prop]);
 115                 }
 116             };
 117
 118         var listFiltering = {};
 119
 120         listFiltering.removeEmptyFilters = function (node) {
 121             if(node.referenceNode && node.referenceNode.filters){
 122                 var wasDeleted = false;
 123                 node.referenceNode.filters = node.referenceNode.filters.filter(function(filter){
 124                     if(filter.filteredValues && filter.filteredValues.length){
 125                         return true;
 126                     }else{
 127                         wasDeleted = true;
 128                         return false;
 129                     }
 130                 });
 131
 132                 if(wasDeleted){
 133                     listFiltering.switchFilter(node,0,true);
 134                 }
 135             }
 136         };
 137
 138         listFiltering.showListFilterWin = function (filterRootNode,node) {
 139             if(!node.searchedPath.length){
 140                 getNodePathInStructure(filterRootNode,node);
 141             }
 142
 143             if(!node.referenceNode){
 144                 node.referenceNode = filterRootNode;
 145                 node.searchedPath.forEach(function(elem){
 146                     node.referenceNode = node.referenceNode.children[elem];
 147                 });
 148             }
 149
 150             if(!node.referenceNode.filterNodes.length){
 151                 FilterNodeWrapperService.init(node);
 152                 node.referenceNode.filterNodes = node.getNewFilterElement();
 153             }
 154
 155             if(!(node.referenceNode.filters && node.referenceNode.filters.length)){
 156                 node.referenceNode.filters.push({name : 'Filter 1 name', active : 1});
 157             }else{
 158                 listFiltering.getFilterData(node);
 159                 listFiltering.removeEmptyFilters(node);
 160             }
 161         };
 162
 163         listFiltering.createNewFilter = function (node) {
 164             node.referenceNode.filters.push({name : 'Filter ' + (node.referenceNode.filters.length+1) + ' name', active : 1});
 165
 166             listFiltering.switchFilter(node,node.referenceNode.filters.length-1);
 167         };
 168
 169         listFiltering.getFilterData = function (node) {
 170             node.referenceNode.filters[node.currentFilter].filteredValues = node.referenceNode.filterNodes.map(function(element){
 171                 var requestData = {};
 172                 element.buildRequest(RequestBuilderService, requestData);
 173                 return requestData;
 174             }).filter(function(item){
 175                 return $.isEmptyObject(item) === false;
 176             });
 177         };
 178
 179         listFiltering.switchFilter = function (node,showedFilter,fromRemoveEmptyFilters) {
 180             if(node.referenceNode.filters.length){
 181                 if(!fromRemoveEmptyFilters){
 182                     listFiltering.getFilterData(node);
 183                 }
 184                 clearFilterNodes(node);
 185                 node.currentFilter = showedFilter;
 186                 loadFilterNodes(node);
 187             }else{
 188                 node.currentFilter = 0;
 189             }
 190         };
 191
 192         listFiltering.applyFilter = function (node) {
 193             listFiltering.getFilterData(node);
 194             listFiltering.removeEmptyFilters(node);
 195
 196             node.filteredListData = node.listData.slice().filter(function(element){
 197                 return node.referenceNode.filters.filter(function(fil){
 198                     return fil.active === 1;
 199                 }).some(function(filter){
 200                     return filter.filteredValues.every(function(filterValue){
 201                         filterResult = null;
 202                         getFilterResult(element,filterValue,node);
 203                         return filterResult;
 204                     });
 205                 });
 206             });
 207
 208             getActElementFilter(node);
 209             // console.info('applyFilter node',node,'node.referenceNode.filterNodes',node.referenceNode.filterNodes,'node.referenceNode.filters',node.referenceNode.filters);
 210         };
 211
 212         listFiltering.clearFilterData = function (node, changeAct, filterForClear, removeFilters) {
 213             if(filterForClear){
 214                 filterForClear--;
 215                 if(node.referenceNode.filters.length === 1){
 216                     node.referenceNode.filters = [];
 217                     node.referenceNode.filters.push({name : 'Filter 1 name', active : 1});
 218                     clearFilterNodes(node);
 219                 }else{
 220                     node.referenceNode.filters.splice(filterForClear,1);
 221                     node.currentFilter = 0;
 222                     clearFilterNodes(node);
 223                     loadFilterNodes(node);
 224                 }
 225             }else{
 226                 if(removeFilters){
 227                     node.referenceNode.filters = [];
 228                     clearFilterNodes(node);
 229                     node.currentFilter = 0;
 230                 }else{
 231                     node.referenceNode.filters.forEach(function(filter){
 232                         filter.active = 2;
 233                     });
 234                     listFiltering.getFilterData(node);
 235                     listFiltering.removeEmptyFilters(node);
 236                 }
 237                 node.filteredListData = [];
 238             }
 239
 240             if(changeAct){
 241                 getActElementFilter(node);
 242             }
 243
 244         };
 245
 246         return listFiltering;
 247     }
 248
 249     ListFilteringService.$inject=['FilterNodeWrapperService', 'RequestBuilderService'];
 250
 251     return ListFilteringService;
 252
 253 });