/** * Override default `toJSON` to return DSL representation for `sort` parameter. * * @override * @returns {Object|string} returns an Object which maps to the elasticsearch query DSL */ toJSON() { const geoPointIsNil = isNil(this._geoPoint); const scriptIsNil = isNil(this._script); if (geoPointIsNil && scriptIsNil) { if (isEmpty(this._opts)) return this._field; if ( Object.keys(this._opts).length === 1 && has(this._opts, 'order') ) { return { [this._field]: this._opts.order }; } } let repr; // Should I pick only the accepted properties here? if (!geoPointIsNil) { repr = { _geo_distance: Object.assign( { [this._field]: this._geoPoint }, this._opts ) }; } else if (!scriptIsNil) { repr = { _script: Object.assign({ script: this._script }, this._opts) }; } else { repr = { [this._field]: this._opts }; } return recursiveToJSON(repr); }
// eslint-disable-next-line require-jsdoc constructor(field, docType) { super('percolate'); if (!isNil(field)) this._queryOpts.field = field; // Delegate this to method: if (!isNil(docType)) this._queryOpts.document_type = docType; }
/** * @param {string} consumer - the consumer name * @param {string} provider - the provider name * @param {number} port - the mock service port, defaults to 1234 * @param {string} host - the mock service host, defaults to 127.0.0.1 */ constructor (consumer, provider, port = 1234, host = '127.0.0.1', ssl = false) { if (isNil(consumer) || isNil(provider)) { throw new Error('Please provide the names of the provider and consumer for this Pact.') } if (isNil(port)) { throw new Error('Please provide the port to connect to the Pact Mock Server.') } this._request = new Request() this._baseURL = `${ssl ? 'https' : 'http'}://${host}:${port}` this._pactDetails = { consumer: { name: consumer }, provider: { name: provider } } }
/** * Override default `toJSON` to return DSL representation for the request body search * * @override * @returns {Object} returns an Object which maps to the elasticsearch query DSL */ toJSON() { const dsl = recursiveToJSON(this._body); if (!isEmpty(this._aggs)) dsl.aggs = recMerge(this._aggs); if (!isEmpty(this._suggests) || !isNil(this._suggestText)) { dsl.suggest = recMerge(this._suggests); if (!isNil(this._suggestText)) { dsl.suggest.text = this._suggestText; } } return dsl; }
// eslint-disable-next-line require-jsdoc constructor(name, aggType, refUrl, bucketsPath) { super(name, aggType); this._refUrl = refUrl; if (!isNil(bucketsPath)) this._aggsDef.buckets_path = bucketsPath; }
/** * Check the instance for object representation of Geo Point. * If representation is null, new object is initialised. * If it is not null, warning is logged and point is overwritten. * @private */ _checkObjRepr() { if (isNil(this._point)) this._point = {}; else if (!isObject(this._point)) { this._warnMixedRepr(); this._point = {}; } }
/** * Sets the Geo Point value expressed as an object, * with `lat` and `lon` keys. * * @param {Object} point * @returns {GeoPoint} returns `this` so that calls can be chained * @throws {TypeError} If `point` is not an instance of object */ object(point) { checkType(point, Object); !isNil(this._point) && this._warnMixedRepr(); this._point = point; return this; // This doesn't make much sense. What else are you gonna call? }
// eslint-disable-next-line require-jsdoc constructor(queryType, field) { super(queryType); this._field = null; this._fieldOpts = {}; if (!isNil(field)) this._field = field; }
// eslint-disable-next-line require-jsdoc constructor(field, order) { this._field = field; this._opts = {}; this._geoPoint = null; this._script = null; if (!isNil(order)) this.order(order); }
/** * Sets the moving average weighting model that we wish to use. Optional. * * @example * const agg = esb.movingAverageAggregation('the_movavg', 'the_sum') * .model('simple') * .window(30); * * @example * const agg = esb.movingAverageAggregation('the_movavg', 'the_sum') * .model('ewma') * .window(30) * .settings({ alpha: 0.8 }); * * @param {string} model Can be `simple`, `linear`, * `ewma` (aka "single-exponential"), `holt` (aka "double exponential") * or `holt_winters` (aka "triple exponential"). * Default is `simple` * @returns {MovingAverageAggregation} returns `this` so that calls can be chained */ model(model) { if (isNil(model)) invalidModelParam(model); const modelLower = model.toLowerCase(); if (!MODEL_SET.has(modelLower)) invalidModelParam(model); this._aggsDef.model = modelLower; return this; }
/** * Sets the distance calculation mode, `arc` or `plane`. * The `arc` calculation is the more accurate. * The `plane` is the faster but least accurate. * * @example * const agg = esb.geoDistanceAggregation('rings_around_amsterdam', 'location') * .origin(esb.geoPoint().string('52.3760, 4.894')) * .unit('km') * .distanceType('plane') * .ranges([{ to: 100 }, { from: 100, to: 300 }, { from: 300 }]); * * @param {string} type * @returns {GeoDistanceAggregation} returns `this` so that calls can be chained * @throws {Error} If `type` is neither `plane` nor `arc`. */ distanceType(type) { if (isNil(type)) invalidDistanceTypeParam(type); const typeLower = type.toLowerCase(); if (typeLower !== 'plane' && typeLower !== 'arc') invalidDistanceTypeParam(type); this._aggsDef.distance_type = typeLower; return this; }
/** * Sets the relationship between Query and indexed data * that will be used to determine if a Document should be matched or not. * * @param {string} relation Can be one of `WITHIN`, `CONTAINS`, `DISJOINT` * or `INTERSECTS`(default) * @returns {GeoShapeQuery} returns `this` so that calls can be chained */ relation(relation) { if (isNil(relation)) invalidRelationParam(relation); const relationUpper = relation.toUpperCase(); if (!GEO_RELATION_SET.has(relationUpper)) { invalidRelationParam(relation); } this._fieldOpts.relation = relationUpper; return this; }
/** * Sets the suggest mode which controls what suggestions are included * or controls for what suggest text terms, suggestions should be suggested. * * Three possible values can be specified: * - `missing`: Only provide suggestions for suggest text terms that * are not in the index. This is the default. * - `popular`: Only suggest suggestions that occur in more docs * than the original suggest text term. * - `always`: Suggest any matching suggestions based on terms in the suggest text. * * @param {string} mode Can be `missing`, `popular` or `always` * @returns {TermSuggester} returns `this` so that calls can be chained. * @throws {Error} If `mode` is not one of `missing`, `popular` or `always`. */ suggestMode(mode) { if (isNil(mode)) invalidSuggestModeParam(mode); const modeLower = mode.toLowerCase(); if (!SUGGEST_MODE_SET.has(modeLower)) { invalidSuggestModeParam(mode); } this._suggestOpts.suggest_mode = modeLower; return this; }
/** * Sets the string distance implementation to use for comparing how similar * suggested terms are. * * Five possible values can be specified: * - `internal`: The default based on `damerau_levenshtein` but highly optimized for * comparing string distance for terms inside the index. * - `damerau_levenshtein`: String distance algorithm based on Damerau-Levenshtein * algorithm. * - `levenstein`: String distance algorithm based on Levenstein edit distance * algorithm. * - `jarowinkler`: String distance algorithm based on Jaro-Winkler algorithm. * - `ngram`: String distance algorithm based on character n-grams. * * @param {string} implMethod One of `internal`, `damerau_levenshtein`, `levenstein`, * `jarowinkler`, `ngram` * @returns {TermSuggester} returns `this` so that calls can be chained. * @throws {Error} If `implMethod` is not one of `internal`, `damerau_levenshtein`, * `levenstein`, `jarowinkler` or ngram`. */ stringDistance(implMethod) { if (isNil(implMethod)) invalidStringDistanceParam(implMethod); const implMethodLower = implMethod.toLowerCase(); if (!STRING_DISTANCE_SET.has(implMethodLower)) { invalidStringDistanceParam(implMethod); } this._suggestOpts.string_distance = implMethodLower; return this; }
/** * Set order for sorting. The order defaults to `desc` when sorting on the `_score`, * and defaults to `asc` when sorting on anything else. * * @param {string} order The `order` option can have the following values. * `asc`, `desc` to sort in ascending, descending order respectively. * @returns {Sort} returns `this` so that calls can be chained. */ order(order) { if (isNil(order)) invalidOrderParam(order); const orderLower = order.toLowerCase(); if (orderLower !== 'asc' && orderLower !== 'desc') { invalidOrderParam(order); } this._opts.order = orderLower; return this; }
/** * Elasticsearch supports sorting by array or multi-valued fields. * The `mode` option controls what array value is picked for sorting the * document it belongs to. * * The `mode` option can have the following values: * * - `min` - Pick the lowest value. * - `max` - Pick the highest value. * - `sum` - Use the sum of all values as sort value. * Only applicable for number based array fields. * - `avg` - Use the average of all values as sort value. * Only applicable for number based array fields. * - `median` - Use the median of all values as sort value. * Only applicable for number based array fields. * * @example * const sort = esb.sort('price', 'asc').mode('avg'); * * @param {string} mode One of `avg`, `min`, `max`, `sum` and `median`. * @returns {Sort} returns `this` so that calls can be chained. */ mode(mode) { if (isNil(mode)) invalidModeParam(mode); const modeLower = mode.toLowerCase(); if (!SORT_MODE_SET.has(modeLower)) { invalidModeParam(mode); } this._opts.mode = modeLower; return this; }
/** * Set policy for missing data. Optional. * * [Elasticsearch reference](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-pipeline.html#gap-policy) * * @param {string} policy Can be `skip` or `insert_zeros` * @returns {PipelineAggregationBase} returns `this` so that calls can be chained */ gapPolicy(policy) { if (isNil(policy)) invalidGapPolicyParam(policy, this._refUrl); const policyLower = policy.toLowerCase(); if (policyLower !== 'skip' && policyLower !== 'insert_zeros') { invalidGapPolicyParam(policy, this._refUrl); } this._aggsDef.gap_policy = policyLower; return this; }
/** * Sets the sort to control how suggestions should be sorted per * suggest text term. * * Two possible values: * - `score`: Sort by score first, then document frequency and * then the term itself. * - `frequency`: Sort by document frequency first, then similarity * score and then the term itself. * * @param {string} sort Can be `score` or `frequency` * @returns {TermSuggester} returns `this` so that calls can be chained. * @throws {Error} If `sort` is neither `score` nor `frequency`. */ sort(sort) { if (isNil(sort)) invalidSortParam(sort); const sortLower = sort.toLowerCase(); if (sortLower !== 'score' && sortLower !== 'frequency') { invalidSortParam(sort); } this._suggestOpts.sort = sortLower; return this; }
/** * This setting can influence the management of the values used * for de-duplication. Each option will hold up to shard_size * values in memory while performing de-duplication but * the type of value held can be controlled * * @param {string} hint the possible values are `map`, `global_ordinals`, * `global_ordinals_hash` and `global_ordinals_low_cardinality` * @returns {DiversifiedSamplerAggregation} returns `this` so that calls can be chained * @throws {Error} If Execution Hint is outside the accepted set. */ executionHint(hint) { if (isNil(hint)) invalidExecutionHintParam(hint); const hintLower = hint.toLowerCase(); if (!EXECUTION_HINT_SET.has(hintLower)) { invalidExecutionHintParam(hint); } this._aggsDef.execution_hint = hintLower; return this; }
/** * Allows to collapse search results based on field values. The collapsing * is done by selecting only the top sorted document per collapse key. * * The field used for collapsing must be a single valued `keyword` or `numeric` * field with `doc_values` activated * * @example * const reqBody = esb.requestBodySearch() * .query(esb.matchQuery('message', 'elasticsearch')) * .collapse('user') * .sort(esb.sort('likes')) * .from(10); * * @example * // Expand each collapsed top hits with the `inner_hits` option: * const reqBody = esb.requestBodySearch() * .query(esb.matchQuery('message', 'elasticsearch')) * .collapse( * 'user', * esb.innerHits('last_tweets') * .size(5) * .sort(esb.sort('date', 'asc')), * 4 * ) * .sort(esb.sort('likes')) * .from(10); * * @param {string} field * @param {InnerHits=} innerHits Allows to expand each collapsed top hits. * @param {number=} maxConcurrentGroupRequests The number of concurrent * requests allowed to retrieve the inner_hits' per group * @returns {RequestBodySearch} returns `this` so that calls can be chained. * @throws {TypeError} If `innerHits` is not an instance of `InnerHits` */ collapse(field, innerHits, maxConcurrentGroupRequests) { const collapse = (this._body.collapse = { field }); if (!isNil(innerHits)) { checkType(innerHits, InnerHits); collapse.inner_hits = innerHits; collapse.max_concurrent_group_searches = maxConcurrentGroupRequests; } return this; }
exports.checkType = function checkType(instance, type) { if (!(instance instanceof type)) { if (isNil(instance)) { console.warn( `Was expecting instance of ${type.name} but got ${instance}!` ); } else console.warn( `${inspect(instance)} is of the type ${typeof instance}` ); throw new TypeError(`Argument must be an instance of ${type.name}`); } };
/** * Sets the `validation_method` parameter. Can be set to `IGNORE_MALFORMED` to accept * geo points with invalid latitude or longitude, `COERCE` to try and infer correct latitude * or longitude, or `STRICT` (default is `STRICT`). * * Note: The `ignore_malformed` and `coerce` parameters have been removed * from `geo_bounding_box`, `geo_polygon`, and `geo_distance` queries in * elasticsearch 6.0. * * @param {string} method One of `IGNORE_MALFORMED`, `COERCE` or `STRICT`(default) * @returns {GeoQueryBase} returns `this` so that calls can be chained. * @throws {Error} If `method` parameter is not one of `IGNORE_MALFORMED`, `COERCE` or `STRICT` */ validationMethod(method) { if (isNil(method)) invalidValidationMethod(method); const methodUpper = method.toUpperCase(); if ( methodUpper !== 'IGNORE_MALFORMED' && methodUpper !== 'COERCE' && methodUpper !== 'STRICT' ) { invalidValidationMethod(method); } this._queryOpts.validation_method = methodUpper; return this; }
/** * Set the decay mode. * * @param {string} mode Can be one of `linear`, `exp`, and `gauss`. * Defaults to `gauss`. * @returns {DecayScoreFunction} returns `this` so that calls can be chained. */ mode(mode) { if (isNil(mode)) invalidModeParam(mode); const modeLower = mode.toLowerCase(); if ( modeLower !== 'linear' && modeLower !== 'exp' && modeLower !== 'gauss' ) { invalidModeParam(mode); } this._name = mode; return this; }
return async (dispatch, getState) => { const { skipass: searchSkipass } = getState().get('searchSkipass').toJS() dispatch(removeStoredSkipassRequest()) try { await removeSkipass(skipass) dispatch(removeStoredSkipassSuccess(skipass)) if (!isNil(searchSkipass) && searchSkipass.cardNumber === skipass.cardNumber) { dispatch(toggleSkipassCanBeAdded(true)) } } catch (e) { dispatch(removeStoredSkipassFailure(e)) } }
/** * Sets the ordering for buckets * * @example * const agg = esb.histogramAggregation('prices', 'price', 50) * .order('_count', 'desc'); * * @example * const agg = esb.histogramAggregation('prices', 'price', 50) * .order('promoted_products>rating_stats.avg', 'desc') * .agg( * esb.filterAggregation('promoted_products') * .filter(esb.termQuery('promoted', 'true')) * .agg(esb.statsAggregation('rating_stats', 'rating')) * ); * * @param {string} key * @param {string} direction `asc` or `desc` * @returns {HistogramAggregationBase} returns `this` so that calls can be chained */ order(key, direction = 'desc') { if (isNil(direction)) invalidDirectionParam(direction); const directionLower = direction.toLowerCase(); if (directionLower !== 'asc' && directionLower !== 'desc') { invalidDirectionParam(direction); } if (has(this._aggsDef, 'order')) { if (!Array.isArray(this._aggsDef.order)) { this._aggsDef.order = [this._aggsDef.order]; } this._aggsDef.order.push({ [key]: directionLower }); } else { this._aggsDef.order = { [key]: directionLower }; } return this; }
// eslint-disable-next-line require-jsdoc constructor(name, path) { super(name, 'nested'); if (!isNil(path)) this._aggsDef.path = path; }
// eslint-disable-next-line require-jsdoc constructor(script) { super('script_score'); if (!isNil(script)) this._opts.script = script; }
// This is extremely similar to ValueTermQueryBase // Maybe rename, move and reuse it? // eslint-disable-next-line require-jsdoc constructor(field, value) { super('span_term'); if (!isNil(field)) this._field = field; if (!isNil(value)) this._queryOpts.value = value; }
// eslint-disable-next-line require-jsdoc constructor(field) { super('exists'); if (!isNil(field)) this._queryOpts.field = field; }
break case '1.5': result = Math.ceil(1 / getters.getSquareLengthHeight) + Math.ceil(1 / getters.getSquareWidthHeight) break case '2': result = (Math.ceil(1 / getters.getSquareWidthHeight)) * 2 break case '2.5': result = Math.ceil(1 / getters.getSquareLengthHeight) + (Math.ceil(1 / getters.getSquareWidthHeight)) * 2 break } result = (getters.getAreaCommon - getters.getAreaOpening) * result return result }, getAreaCommon (state, getters) { if (isNil(state.building.length) && isNil(state.building.width) && isNil(state.building.height)) { return null } const result = ((toNumber(state.building.length) + toNumber(state.building.width)) * 2) * toNumber(state.building.height) return result }, getAreaOpening (state) { return state.opening.reduce((total, currentIndex) => { return total + isEmpty(currentIndex.width) * isEmpty(currentIndex.height) }, 0) }, checkCommonLess (state, getters) { const common = getters.getAreaCommon === null ? 0 : getters.getAreaCommon if (common !== 0 && common / 2 <= getters.getAreaOpening) { if (i18n.locale === state.language.primary) { state.openingText = 'Площадь проемов не должна превышать общую площадь строения'