New type of filter to get all the values for a field within the current context

src/core_plugins/kibana/index.js

@@ -11,6 +11,7 @@ import { exportApi } from './server/routes/api/export';
 import { homeApi } from './server/routes/api/home';
 import scripts from './server/routes/api/scripts';
 import { registerSuggestionsApi } from './server/routes/api/suggestions';
+import { registerValuesApi } from './server/routes/api/values';
 import { registerFieldFormats } from './server/field_formats/register';
 import { registerTutorials } from './server/tutorials/register';
 import * as systemApi from './server/lib/system_api';
@@ -151,6 +152,7 @@ export default function (kibana) {
       exportApi(server);
       homeApi(server);
       registerSuggestionsApi(server);
+      registerValuesApi(server);
       registerFieldFormats(server);
       registerTutorials(server);
       server.expose('systemApi', systemApi);

src/core_plugins/kibana/server/routes/api/values/index.js

@@ -0,0 +1,5 @@
+import { registerValues } from './register_values';
+
+export function registerValuesApi(server) {
+  registerValues(server);
+}

src/core_plugins/kibana/server/routes/api/values/register_values.js

@@ -0,0 +1,57 @@
+import handleESError from '../../../lib/handle_es_error';
+
+export function registerValues(server) {
+  server.route({
+    path: '/api/kibana/values/{index}',
+    method: ['POST'],
+    handler: async function (req, reply) {
+      const { index } = req.params;
+      const { field } = req.payload;
+      const { query } = req.payload;
+
+      const { callWithRequest } = server.plugins.elasticsearch.getCluster('data');
+      const body = getBody(field, query);
+      let fieldList = [];
+      try {
+
+        const response = await callWithRequest(req, 'search', { index, body });
+        const buckets = response.aggregations.aggResults.buckets;
+        for (let i = 0; i < buckets.length; i < i++) {
+          const currentField = buckets[i].key;
+          if (typeof (currentField) === 'object') {
+            // its an array
+            fieldList = fieldList.concat(currentField);
+          } else {
+            fieldList.push(currentField);
+          }
+        }
+        const uniqueValues = Array.from(new Set(fieldList));
+        reply(uniqueValues);
+      } catch (error) {
+        reply(handleESError(error));
+      }
+    }
+  });
+}
+
+function getBody(field, { query }) {
+  const aggregationSize = 10000;
+  return {
+    size: 0,
+    timeout: '60s',
+    aggs: {
+      aggResults: {
+        terms: {
+          field: field,
+          size: aggregationSize
+        }
+      }
+    },
+    query: query
+  };
+}
+
+// function getEscapedQuery(query = '') {
+//   // https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-regexp-query.html#_standard_operators
+//   return query.replace(/[.?+*|{}[\]()"\\#@&<>~]/g, (match) => `\\${match}`);
+// }

src/ui/public/courier/fetch/request/request_fetch_params_to_body.js

@@ -26,6 +26,7 @@ function emptySearch() {
  * @return {Promise.<string>}
  */
 export function requestFetchParamsToBody(
+  $rootScope,
   requestsFetchParams,
   Promise,
   timeFilter,
@@ -68,6 +69,10 @@ export function requestFetchParamsToBody(
           index = indexList;
         }
 
+
+        $rootScope.filterState = { query: body.query };
+
+
         return JSON.stringify({
           index,
           type: fetchParams.type,

src/ui/public/courier/fetch/request/request_fetch_params_to_body_provider.js

@@ -1,8 +1,9 @@
 import { requestFetchParamsToBody } from './request_fetch_params_to_body';
 
-export function RequestFetchParamsToBodyProvider(Promise, timefilter, kbnIndex, sessionId) {
+export function RequestFetchParamsToBodyProvider($rootScope, Promise, timefilter, kbnIndex, sessionId) {
   return (requestsFetchParams) => (
     requestFetchParamsToBody(
+      $rootScope,
       requestsFetchParams,
       Promise,
       timefilter,

src/ui/public/filter_bar/lib/map_filter.js

@@ -9,6 +9,7 @@ import { FilterBarLibMapMissingProvider } from './map_missing';
 import { FilterBarLibMapQueryStringProvider } from './map_query_string';
 import { FilterBarLibMapGeoBoundingBoxProvider } from './map_geo_bounding_box';
 import { FilterBarLibMapGeoPolygonProvider } from './map_geo_polygon';
+import { FilterBarLibMapValuesProvider } from './map_values';
 import { FilterBarLibMapDefaultProvider } from './map_default';
 
 export function FilterBarLibMapFilterProvider(Promise, Private) {
@@ -41,6 +42,7 @@ export function FilterBarLibMapFilterProvider(Promise, Private) {
     Private(FilterBarLibMapQueryStringProvider),
     Private(FilterBarLibMapGeoBoundingBoxProvider),
     Private(FilterBarLibMapGeoPolygonProvider),
+    Private(FilterBarLibMapValuesProvider),
     Private(FilterBarLibMapDefaultProvider),
   ];
 

src/ui/public/filter_bar/lib/map_values.js

@@ -0,0 +1,10 @@
+export function FilterBarLibMapValuesProvider(Promise) {
+  return function (filter) {
+    const { type, key, value, params } = filter.meta;
+    if (type !== 'values') {
+      return Promise.reject(filter);
+    } else {
+      return Promise.resolve({ type, key, value, params });
+    }
+  };
+}

src/ui/public/filter_editor/filter_editor.html

@@ -68,6 +68,8 @@
             params="filterEditor.params"
           ></filter-params-editor>
         </div>
+
+
       </div>
 
       <!-- DSL editor -->

src/ui/public/filter_editor/lib/filter_editor_utils.js

@@ -27,6 +27,8 @@ export function getParamsFromFilter(filter) {
     params = filter.query ? filter.query.match[key].query : filter.script.script.params.value;
   } else if (type === 'phrases') {
     params = filter.meta.params;
+  } else if (type === 'values') {
+    params = filter.meta.params.values;
   } else if (type === 'range') {
     const range = filter.range ? filter.range[key] : filter.script.script.params;
     const from = _.has(range, 'gte') ? range.gte : range.gt;
@@ -77,6 +79,8 @@ export function buildFilter({ indexPattern, field, operator, params, filterBuild
     filter = filterBuilder.buildRangeFilter(field, { gte: params.range.from, lt: params.range.to }, indexPattern);
   } else if (operator.type === 'exists') {
     filter = filterBuilder.buildExistsFilter(field, indexPattern);
+  } else if (operator.type === 'values') {
+    filter = filterBuilder.buildValuesFilter(field, params, indexPattern);
   }
   filter.meta.negate = operator.negate;
   return filter;

src/ui/public/filter_editor/lib/filter_operators.js

@@ -45,6 +45,12 @@ export const FILTER_OPERATORS = [
     type: 'exists',
     negate: true,
   },
+  {
+    name: 'values',
+    type: 'values',
+    negate: false,
+    fieldTypes: ['string', 'number', 'date', 'ip', 'geo_point', 'geo_shape']
+  },
 ];
 
 export const FILTER_OPERATOR_TYPES = _(FILTER_OPERATORS)

src/ui/public/filter_editor/params_editor/filter_params_controller.js

@@ -0,0 +1,6 @@
+
+export function filterParamsController($http, $scope) {
+  $scope.$on('value_event', function (event, data) {
+    $scope.params = { values: data };
+  });
+}

src/ui/public/filter_editor/params_editor/filter_params_editor.html

@@ -1,4 +1,5 @@
 <ng-switch on="operator.type">
+
   <filter-params-phrase-editor
     ng-switch-when="phrase"
     field="field"
@@ -16,4 +17,11 @@
     field="field"
     params="params"
   ></filter-params-range-editor>
-</ng-switch>
+
+  <filter-params-values-editor
+    ng-switch-when="values"
+    field="field"
+    params="params"
+  ></filter-params-values-editor>
+
+</ng-switch>

src/ui/public/filter_editor/params_editor/filter_params_editor.js

@@ -2,17 +2,23 @@ import { uiModules } from 'ui/modules';
 import template from './filter_params_editor.html';
 import './filter_params_phrase_editor';
 import './filter_params_phrases_editor';
+import './filter_params_values_editor';
 import './filter_params_range_editor';
+import { filterParamsController } from './filter_params_controller';
 
 const module = uiModules.get('kibana');
 module.directive('filterParamsEditor', function () {
+
   return {
     restrict: 'E',
     template,
     scope: {
       field: '=',
       operator: '=',
       params: '='
-    }
+    },
+
+    controllerAs: 'filterParamsEditor',
+    controller: filterParamsController
   };
 });

src/ui/public/filter_editor/params_editor/filter_params_phrase_editor.html

@@ -42,4 +42,4 @@
   >
     Accepted date formats
   </a>
-</small>
+</small>

src/ui/public/filter_editor/params_editor/filter_params_phrases_editor.html

@@ -25,4 +25,4 @@
   >
     <div ng-bind-html="value | highlight: $select.search"></div>
   </ui-select-choices>
-</ui-select>
+</ui-select>

src/ui/public/filter_editor/params_editor/filter_params_range_editor.html

@@ -27,4 +27,4 @@
   >
     Accepted date formats
   </a>
-</small>
+</small>

src/ui/public/filter_editor/params_editor/filter_params_values_controller.js

@@ -0,0 +1,32 @@
+
+
+import _ from 'lodash';
+import chrome from 'ui/chrome';
+
+const baseUrl = chrome.addBasePath('/api/kibana/values');
+
+export function filterParamsValuesController($http, $scope, $rootScope) {
+
+  this.getAllFieldValues = getAllFieldValues;
+
+
+  function getAllFieldValues(field) {
+
+    field = $scope.field;
+    if (!_.get(field, 'aggregatable') || field.type !== 'string') {
+      return Promise.resolve([]);
+    }
+
+    const postParams = {
+      field: field.name,
+      query: $rootScope.filterState
+    };
+
+
+    // TODO pass the response to the scope so that the build function can pick it up
+    $http.post(`${baseUrl}/${field.indexPattern.title}`, postParams)
+      .then(response => {
+        $scope.$emit('value_event', response.data);
+      });
+  }
+}

src/ui/public/filter_editor/params_editor/filter_params_values_editor.html

@@ -0,0 +1,5 @@
+<button
+  class="kuiButton kuiButton--primary"
+  ng-click="filterParamsValuesEditor.getAllFieldValues()">
+  Fetch
+</button>

src/ui/public/filter_editor/params_editor/filter_params_values_editor.js

@@ -0,0 +1,19 @@
+
+import { uiModules } from 'ui/modules';
+import template from './filter_params_values_editor.html';
+import { filterParamsValuesController } from './filter_params_values_controller';
+import './filter_params_input_type';
+
+const module = uiModules.get('kibana');
+module.directive('filterParamsValuesEditor', function () {
+  return {
+    restrict: 'E',
+    template,
+    scope: {
+      field: '=',
+      params: '='
+    },
+    controllerAs: 'filterParamsValuesEditor',
+    controller: filterParamsValuesController
+  };
+});

src/ui/public/filter_manager/lib/index.js

@@ -3,3 +3,4 @@ export { buildPhraseFilter } from './phrase';
 export { buildPhrasesFilter } from './phrases';
 export { buildQueryFilter } from './query';
 export { buildRangeFilter } from './range';
+export { buildValuesFilter } from './values';

src/ui/public/filter_manager/lib/values.js

@@ -0,0 +1,36 @@
+// import { getPhraseScript } from './values';
+
+export function buildValuesFilter(field, params, indexPattern) {
+  const index = indexPattern.id;
+  const type = 'values';
+  const key = field.name;
+  const values = params.values;
+
+  const filter = {
+    meta: { index, type, key, values, params }
+  };
+
+  // if (field.scripted) {
+  //   should = params.map((value) => ({
+  //     script: getPhraseScript(field, value)
+  //   }));
+  // } else {
+  //   should = params.map((value) => ({
+  //     match_phrase: {
+  //       [field.name]: value
+  //     }
+  //   }));
+  // }
+
+  filter.query = {
+    bool: {
+      filter: {
+        terms: {
+          [field.name]: values
+        }
+      }
+    }
+  };
+
+  return filter;
+}