982bda9272fb2a7b3c396f8d257c537e906cbe14
[aai/sparky-fe.git] / src / generic-components / filterBar / FilterBarUtils.js
1 /*
2  * ============LICENSE_START===================================================
3  * SPARKY (AAI UI service)
4  * ============================================================================
5  * Copyright © 2017 AT&T Intellectual Property.
6  * Copyright © 2017 Amdocs
7  * All rights reserved.
8  * ============================================================================
9  * Licensed under the Apache License, Version 2.0 (the "License");
10  * you may not use this file except in compliance with the License.
11  * You may obtain a copy of the License at
12  *
13  *      http://www.apache.org/licenses/LICENSE-2.0
14  *
15  * Unless required by applicable law or agreed to in writing, software
16  * distributed under the License is distributed on an "AS IS" BASIS,
17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18  * See the License for the specific language governing permissions and
19  * limitations under the License.
20  * ============LICENSE_END=====================================================
21  *
22  * ECOMP and OpenECOMP are trademarks
23  * and service marks of AT&T Intellectual Property.
24  */
25 import isEmpty from 'lodash/isEmpty';
26 import moment from 'moment-timezone';
27 import {
28   POST,
29   POST_HEADER
30 } from 'app/networking/NetworkConstants.js';
31 import {
32   UNIFIED_FILTERS_URL,
33   DISCOVER_FILTERS_ERROR_MSG,
34   DATE_TIME_ZONE,
35   FILTER_ATTRIBUTE_TO,
36   FILTER_ATTRIBUTE_FROM,
37   FILTER_ATTRIBUTE_CODE,
38   FILTER_ATTRIBUTE_VALUES,
39   FILTER_ATTRIBUTE_CONTROLS,
40   FILTER_ATTRIBUTE_DEFAULT_VALUE,
41   FILTER_TYPE_ENUM,
42   filterBarActionTypes
43 } from 'generic-components/filterBar/FilterBarConstants.js';
44 import {
45   MESSAGE_LEVEL_WARNING
46 } from 'utils/GlobalConstants.js';
47 import {
48   getSetGlobalMessageEvent
49 } from 'app/globalInlineMessageBar/GlobalInlineMessageBarActions.js';
50
51 export function buildFilterValueMap(filterValueString) {
52   let filterValueObj = {};
53   let filters = filterValueString.split(',');
54
55   for (let filterIndex in filters) {
56     let filterStringParts = filters[filterIndex].split('=');
57
58     filterValueObj[filterStringParts[0]] = filterStringParts[1];
59   }
60
61   return filterValueObj;
62 }
63
64 export function buildFilterValueMapFromObj(filterValues) {
65   let filterValueObj = {};
66
67   for (let filterIndex in filterValues) {
68     filterValueObj[filterValues[filterIndex].filterId] = filterValues[filterIndex].filterValue;
69   }
70
71   return filterValueObj;
72 }
73
74 export function getFilterListQueryString(filterValueList) {
75   let filterQueryList = [];
76
77   for (let filter in filterValueList) {
78     if (filterValueList[filter]) {
79       filterQueryList.push(
80         {
81           'filterId': filter,
82           'filterValue': filterValueList[filter]
83         }
84       );
85     }
86   }
87
88   return filterQueryList;
89 }
90
91 function getFilterSearchURL() {
92   return UNIFIED_FILTERS_URL.replace('@@IP-ADDRESS@@', document.location.hostname);
93 }
94
95 function getFiltersQueryObject(viewName) {
96   return {
97     'viewName': viewName
98   };
99 }
100
101 function getFiltersEvent(actionType, filterList) {
102   return {
103     type: actionType,
104     data: filterList
105   };
106 }
107
108 export function getUnifiedFilters(viewName, actionType) {
109   return dispatch => {
110     return fetch(getFilterSearchURL(), {
111       credentials: 'same-origin',
112       method: POST,
113       headers: POST_HEADER,
114       body: JSON.stringify(getFiltersQueryObject(viewName))
115     }).then(
116       (response) => response.json()
117     ).then(
118       (responseJson) => {
119         dispatch(
120           getFiltersEvent(actionType, responseJson.filters)
121         );
122       }
123     ).catch(
124       () => {
125         dispatch(getSetGlobalMessageEvent(DISCOVER_FILTERS_ERROR_MSG, MESSAGE_LEVEL_WARNING));
126       }
127     );
128   };
129 }
130
131 function extractConvertedDateValues(dateValues) {
132   let convertedValues = {};
133   if (dateValues.from) {
134     let startMoment = moment(dateValues.from);
135     convertedValues.startDate = startMoment.toDate();
136     convertedValues.time_zone = startMoment.format(DATE_TIME_ZONE);
137   }
138
139   if (dateValues.to) {
140     let endMoment = moment(dateValues.to);
141     convertedValues.endDate = endMoment.toDate();
142     convertedValues.time_zone = endMoment.format(DATE_TIME_ZONE);
143   }
144
145   convertedValues.code = dateValues.code;
146
147   return convertedValues;
148 }
149
150 function convertFilterValues(filterValues) {
151   let convertedFilterValues = {};
152
153   for (let filterId in filterValues) {
154     if (filterValues.hasOwnProperty(filterId) &&
155       !isEmpty(filterValues[filterId]) && !isEmpty(filterValues[filterId].controls)) {
156       let controls = filterValues[filterId].controls;
157       let firstControlKey = Object.keys(controls)[0];
158       if (controls[firstControlKey][FILTER_ATTRIBUTE_VALUES][FILTER_ATTRIBUTE_FROM] ||
159         controls[firstControlKey][FILTER_ATTRIBUTE_VALUES][FILTER_ATTRIBUTE_TO]) {
160         // TODO should check against filter type (ex: dropdown or date)
161         // rather than assuming value attributes (ex: 'to' or 'from')
162         convertedFilterValues[filterId] =
163           extractConvertedDateValues(controls[firstControlKey][FILTER_ATTRIBUTE_VALUES]);
164       } else {
165         let codeValue = controls[firstControlKey][FILTER_ATTRIBUTE_VALUES][FILTER_ATTRIBUTE_CODE];
166         convertedFilterValues[filterId] = codeValue;
167       }
168     }
169   }
170
171   return convertedFilterValues;
172 }
173
174 function combineMissingFilters(filterValues, allFilters) {
175   let allFilterIds = Object.keys(allFilters);
176
177   for (let id in allFilterIds) {
178     if (!filterValues.hasOwnProperty(allFilterIds[id])) {
179       filterValues[allFilterIds[id]] = '';
180     }
181   }
182
183   return filterValues;
184 }
185
186 function getFilterSelectionEvent(selectedValuesMap, convertedValues) {
187   return {
188     type: filterBarActionTypes.NEW_SELECTIONS,
189     data: {
190       selectedValuesMap: convertedValues,
191       unifiedValues: selectedValuesMap
192     }
193   };
194 }
195
196 export function processFilterSelection(filterValues, allFilters) {
197   let convertedFilterValues = convertFilterValues(filterValues);
198   let combinedFilterValues = combineMissingFilters(convertedFilterValues, allFilters);
199
200   // dispatch NEW_SELECTION event type with converted values as the data
201   return getFilterSelectionEvent(filterValues, combinedFilterValues);
202 }
203
204 export function setNonConvertedFilterValues(nonConvertedValues) {
205   return {
206     type: filterBarActionTypes.SET_NON_CONVERTED_VALUES,
207     data: nonConvertedValues
208   };
209 }
210
211 function convertedFilterValuesEvent(nonConvertedValues, convertedValues) {
212   return {
213     type: filterBarActionTypes.SET_CONVERTED_VALUES,
214     data: {
215       nonConvertedValues: nonConvertedValues,
216       convertedValues: convertedValues
217     }
218   };
219 }
220
221 function mapValuesToOption(filterOptions, nonConvertedValue) {
222   let mappedValues = {};
223
224   // loop over options to find match for value
225   for (let i in filterOptions) {
226     if (filterOptions[i].code === nonConvertedValue) {
227       // found the matching
228       mappedValues = filterOptions[i];
229       break;
230     }
231   }
232
233   return mappedValues;
234 }
235
236 function mapValuesToDateOption(nonConvertedValue) {
237   let mappedValues = {};
238
239   if (nonConvertedValue.startDate) {
240     mappedValues.from = new Date(nonConvertedValue.startDate);
241   } else {
242     mappedValues.from = null;
243   }
244
245   if (nonConvertedValue.endDate) {
246     mappedValues.to = new Date(nonConvertedValue.endDate);
247   } else {
248     mappedValues.to = null;
249   }
250
251   mappedValues.code = nonConvertedValue.code;
252
253   return mappedValues;
254 }
255
256 function mapValuesToFilter(nonConvertedValues, allFilters, currentlySetFilterValues) {
257   let convertedValues = {};
258
259   for (let nonConvertedId in nonConvertedValues) {
260     if (nonConvertedValues[nonConvertedId] !== '') {
261       let matchingFilterObj = allFilters[nonConvertedId];
262       let filterControlId = Object.keys(matchingFilterObj.controls)[0];
263       let mappedValue = {};
264
265       if (matchingFilterObj[FILTER_ATTRIBUTE_CONTROLS][filterControlId].type === FILTER_TYPE_ENUM.DATE) {
266         mappedValue = mapValuesToDateOption(nonConvertedValues[nonConvertedId]);
267       } else {
268         mappedValue = mapValuesToOption(matchingFilterObj[FILTER_ATTRIBUTE_CONTROLS][filterControlId].options,
269           nonConvertedValues[nonConvertedId]);
270       }
271
272       let values = {};
273       values[FILTER_ATTRIBUTE_VALUES] = mappedValue;
274       let filterControlers = {};
275       filterControlers[filterControlId] = values;
276       let filter = {};
277       filter[FILTER_ATTRIBUTE_CONTROLS] = filterControlers;
278       convertedValues[nonConvertedId] = filter;
279     } else if (!isEmpty(currentlySetFilterValues[nonConvertedId])) {
280       // currently a value is set for this filter, need to ensure we map this filter
281       // to an empty value so that it is cleared/reset
282       let matchingFilterObj = allFilters[nonConvertedId];
283       let filterControlId = Object.keys(matchingFilterObj.controls)[0];
284       let mappedValue = {};
285       let values = {};
286       values[FILTER_ATTRIBUTE_VALUES] = mappedValue;
287       let filterControlers = {};
288       filterControlers[filterControlId] = values;
289       let filter = {};
290       filter[FILTER_ATTRIBUTE_CONTROLS] = filterControlers;
291       convertedValues[nonConvertedId] = filter;
292     }
293   }
294
295   return convertedValues;
296 }
297
298 export function convertNonConvertedValues(nonConvertedValues, allFilters, currentlySetFilterValues) {
299   let convertedValues = mapValuesToFilter(nonConvertedValues, allFilters, currentlySetFilterValues);
300   return convertedFilterValuesEvent(nonConvertedValues, convertedValues);
301 }
302
303 export function clearFilters() {
304   return {
305     type: filterBarActionTypes.CLEAR_FILTERS
306   };
307 }
308
309 function getSetUnifiedFilterValuesEvent(unifiedValues) {
310   return {
311     type: filterBarActionTypes.SET_UNIFIED_VALUES,
312     data: unifiedValues
313   };
314 }
315
316 function getFilterDefault(filters, filterId) {
317   let filterControlId = Object.keys(filters[filterId][FILTER_ATTRIBUTE_CONTROLS])[0];
318   let defaultValue = filters[filterId][FILTER_ATTRIBUTE_CONTROLS][filterControlId][FILTER_ATTRIBUTE_DEFAULT_VALUE];
319   if (!defaultValue) {
320     defaultValue = {};
321   }
322   return defaultValue;
323 }
324
325 export function setFilterSelectionsToDefaults(filters, filterValues) {
326   let defaultFilterMap = {};
327
328   for (let filterId in filters) {
329     let filterDefaultValue = getFilterDefault(filters, filterId);
330     if (!isEmpty(filterDefaultValue) || (filterValues && filterValues[filterId])) {
331       let filterControlId = Object.keys(filters[filterId][FILTER_ATTRIBUTE_CONTROLS])[0];
332       let controller = {};
333       controller.values = filterDefaultValue;
334       let controllers = {};
335       controllers[filterControlId] = controller;
336       let controls = {};
337       controls.controls = controllers;
338       defaultFilterMap[filterId] = controls;
339     }
340   }
341
342   if (isEmpty(defaultFilterMap)) {
343     // there are no default values, so need to ensure all filters get cleared,
344     // but just incase this 'clearing'
345     let combinedValues = combineMissingFilters(defaultFilterMap, filters);
346     return setNonConvertedFilterValues(combinedValues);
347   } else {
348     // jsut set the Unified Filter Value which will be sent down to the filter (filter
349     // will set itself to the default value and then send notification back up of the selection
350     return getSetUnifiedFilterValuesEvent(defaultFilterMap);
351   }
352 }

© 2017 ONAP. Copyright © The Linux Foundation ®. All Rights Reserved.
The Linux Foundation has registered trademarks and uses trademarks.
For a list of trademarks of The Linux Foundation, please see our Trademark Usage page.
Linux is a registered trademark of Linus Torvalds.
Privacy Policy and Terms of Use