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].filterType) {
  84                         continue;
  85                     }
  86
  87                     if(!filterValue[i].hasOwnProperty('value') && !filterValue[i].hasOwnProperty('selectboxBitsValue') && !filterValue[i].hasOwnProperty('bitsValue') &&
  88                         !filterValue[i].hasOwnProperty('filterRangeFrom') && !filterValue[i].hasOwnProperty('filterRangeTo') && element[i]){
  89                         getFilterResult(element[i],filterValue[i]);
  90                     }else{
  91                         if(filterValue[i].selectboxBitsValue && filterValue[i].selectboxBitsValue.length){
  92                             filterResult = filterValue[i].getResult(element,filterValue[i].selectboxBitsValue,i);
  93                         }else{
  94                             if((filterValue[i].filterRangeFrom && filterValue[i].filterRangeFrom !== '') || (filterValue[i].filterRangeTo && filterValue[i].filterRangeTo !== '')){
  95                                 filterResult = filterValue[i].getFilterResult[filterValue[i].filterType](element,filterValue[i].filterRangeFrom,filterValue[i].filterRangeTo,i);
  96                             }else if(filterValue[i].bitsValue && filterValue[i].bitsValue !== ''){
  97                                 filterResult = filterValue[i].getFilterResult[filterValue[i].filterType](element,filterValue[i].bitsValue,i);
  98                             }else {
  99                                 filterResult = filterValue[i].getFilterResult[filterValue[i].filterType](element,filterValue[i].value,i);
 100                             }
 101                         }
 102                     }
 103                 }
 104             },
 105
 106             getActElementFilter = function (node) {
 107                 var actData = [];
 108
 109                 node.actElemIndex = 0;
 110                 if(node.filteredListData && node.filteredListData.length){
 111                     actData = node.filteredListData[node.actElemIndex];
 112                 }else{
 113                     actData = node.listData[node.actElemIndex];
 114                 }
 115
 116                 node.actElemStructure.clear();
 117                 for (var prop in actData) {
 118                     node.actElemStructure.fillListElement(prop, actData[prop]);
 119                 }
 120             };
 121
 122         var listFiltering = {};
 123
 124         listFiltering.removeEmptyFilters = function (node) {
 125             if(node.referenceNode && node.referenceNode.filters){
 126                 var wasDeleted = false;
 127                 node.referenceNode.filters = node.referenceNode.filters.filter(function(filter){
 128                     if(filter.filteredValues && filter.filteredValues.length){
 129                         return true;
 130                     }else{
 131                         wasDeleted = true;
 132                         return false;
 133                     }
 134                 });
 135
 136                 if(wasDeleted){
 137                     listFiltering.switchFilter(node,0,true);
 138                 }
 139             }
 140         };
 141
 142         listFiltering.showListFilterWin = function (filterRootNode,node) {
 143             if(!node.searchedPath.length){
 144                 getNodePathInStructure(filterRootNode,node);
 145             }
 146
 147             if(!node.referenceNode){
 148                 node.referenceNode = filterRootNode;
 149                 node.searchedPath.forEach(function(elem){
 150                     node.referenceNode = node.referenceNode.children[elem];
 151                 });
 152             }
 153
 154             if(!node.referenceNode.filterNodes.length){
 155                 FilterNodeWrapperService.init(node);
 156                 node.referenceNode.filterNodes = node.getNewFilterElement();
 157             }
 158
 159             if(!(node.referenceNode.filters && node.referenceNode.filters.length)){
 160                 node.referenceNode.filters.push({name : 'Filter 1 name', active : 1});
 161             }else{
 162                 listFiltering.getFilterData(node);
 163                 listFiltering.removeEmptyFilters(node);
 164             }
 165         };
 166
 167         listFiltering.createNewFilter = function (node) {
 168             node.referenceNode.filters.push({name : 'Filter ' + (node.referenceNode.filters.length+1) + ' name', active : 1});
 169
 170             listFiltering.switchFilter(node,node.referenceNode.filters.length-1);
 171         };
 172
 173         listFiltering.getFilterData = function (node) {
 174             node.referenceNode.filters[node.currentFilter].filteredValues = node.referenceNode.filterNodes.map(function(element){
 175                 var requestData = {};
 176                 element.buildRequest(RequestBuilderService, requestData);
 177                 return requestData;
 178             }).filter(function(item){
 179                 return $.isEmptyObject(item) === false;
 180             });
 181         };
 182
 183         listFiltering.switchFilter = function (node,showedFilter,fromRemoveEmptyFilters) {
 184             if(node.referenceNode.filters.length){
 185                 if(!fromRemoveEmptyFilters){
 186                     listFiltering.getFilterData(node);
 187                 }
 188                 clearFilterNodes(node);
 189                 node.currentFilter = showedFilter;
 190                 loadFilterNodes(node);
 191             }else{
 192                 node.currentFilter = 0;
 193             }
 194         };
 195
 196         listFiltering.applyFilter = function (node) {
 197             listFiltering.getFilterData(node);
 198             listFiltering.removeEmptyFilters(node);
 199
 200             node.filteredListData = node.listData.slice().filter(function(element){
 201                 return node.referenceNode.filters.filter(function(fil){
 202                     return fil.active === 1;
 203                 }).some(function(filter){
 204                     return filter.filteredValues.every(function(filterValue){
 205                         filterResult = null;
 206                         getFilterResult(element,filterValue,node);
 207                         return filterResult;
 208                     });
 209                 });
 210             });
 211
 212             getActElementFilter(node);
 213             // console.info('applyFilter node',node,'node.referenceNode.filterNodes',node.referenceNode.filterNodes,'node.referenceNode.filters',node.referenceNode.filters);
 214         };
 215
 216         listFiltering.clearFilterData = function (node, changeAct, filterForClear, removeFilters) {
 217             if(filterForClear){
 218                 filterForClear--;
 219                 if(node.referenceNode.filters.length === 1){
 220                     node.referenceNode.filters = [];
 221                     node.referenceNode.filters.push({name : 'Filter 1 name', active : 1});
 222                     clearFilterNodes(node);
 223                 }else{
 224                     node.referenceNode.filters.splice(filterForClear,1);
 225                     node.currentFilter = 0;
 226                     clearFilterNodes(node);
 227                     loadFilterNodes(node);
 228                 }
 229             }else{
 230                 if(removeFilters){
 231                     node.referenceNode.filters = [];
 232                     clearFilterNodes(node);
 233                     node.currentFilter = 0;
 234                 }else{
 235                     node.referenceNode.filters.forEach(function(filter){
 236                         filter.active = 2;
 237                     });
 238                     listFiltering.getFilterData(node);
 239                     listFiltering.removeEmptyFilters(node);
 240                 }
 241                 node.filteredListData = [];
 242             }
 243
 244             if(changeAct){
 245                 getActElementFilter(node);
 246             }
 247
 248         };
 249
 250         return listFiltering;
 251     }
 252
 253     ListFilteringService.$inject=['FilterNodeWrapperService', 'RequestBuilderService'];
 254
 255     return ListFilteringService;
 256
 257 });