_.each(result.Results, (v, k) => {
                        if (_.filter(v.Values, x => x.Hits > 0).length < 2) {
                            delete result.Results[k];
                            return;
                        }
                        v.Values = _.chain(v.Values)
                            .map((x) => {

                                var val = JSON.stringify(x.Range)
                                    .replace(/^\"|\"$/gi, "")
                                    .replace(/\:/gi, "\\:")
                                    .replace(/\(/gi, "\\(")
                                    .replace(/\)/gi, "\\)")
                                ;

                                if (x.Range.indexOf(" TO ") <= 0 || x.Range.indexOf("[") !== 0) {
                                    val = val.replace(/\ /gi, "\\ ");
                                }
                                val = encodeURIComponent(val);
                                x.q = k + ":" + val;

                                x.Range = x.Range.replace(/^\[Dx/, "").replace(/ Dx/, " ").replace(/\]$/, "").replace(/ TO /, "-")
                                    return x;
                            })
                            .filter((x) => x.Hits > 0)
                            .sortBy((x) => x.Range)
                            .value();
                    });

 save() {
     _.chain(this.tnxs)
         .forEach((t:Transaction) => {
             this._tnxService.saveItem(t);
             this._pTnxService.deleteItem(t);
         });
 }

 static respondToResourceGET<T>(requestBody, res, dao: DAO<T>, whereArray: string[], likeArray: string[]) {
     let whereQuery = _.omit(_.pick(requestBody, whereArray),
         function (value, key, object) {
             return value === "";
         });
     let likeQuery_ = _.chain(requestBody)
         .pick(requestBody, likeArray)
         .omit(function (value, key, object) {
             return value === "";
         }).value();
     let likeQuery = _.mapObject(likeQuery_, function (value, key) {
         return "%" + value + "%";
     });
     dao.find({
         where: whereQuery, like: likeQuery, orderBy: requestBody.orderBy
     }, function (err, results) {
         if (err) {
             APIHelper.sendDatabaseErrorResponse(res, err);
         } else {
             if (results.length === 0) {
                 APIHelper.sendNotFoundResponse(res, "Not found.");
             } else {
                 APIHelper.sendResponse(res, results);
             }
         }
     });
 }

 checkMembershipUnicity: async (block:BlockDTO, conf:ConfDTO, index:IndexEntry[]) => {
   const mindex = Indexer.mindex(index);
   const pubkeys = _.chain(mindex).pluck('pub').uniq().value();
   if (pubkeys.length !== mindex.length) {
     throw Error('Unicity constraint PUBLIC_KEY on MINDEX is not respected');
   }
   return true;
 },

  public static isEmpty(queryBuilderExpression: QueryBuilderExpression) {
    const allNonEmptyValues = _.chain(queryBuilderExpression)
      .values()
      .compact()
      .value();

    return _.isEmpty(allNonEmptyValues);
  }

 update() {
     _.chain(this.tnxs)
         .filter(t=> t.accountId == this.selectedFrom)
         .forEach((t:Transaction) => {
             t.accountId = this.selectedTo;
             this._pTnxService.updateItem(t);
         });
 }

    return through2.obj(function (chunk, enc, cb) {
        const pushGerritEventForward = (gerritEvent: GerritEvent) => this.push(gerritEvent);

        _.chain(getGerritEventsStringByChunk(chunk))
        .compact()
        .map(parseToGerritEvent)
        .compact()
        .map(pushGerritEventForward);

        cb();
    });

  public instantiateToString(object: IQueryResult, instantiateOptions: IInstantiateTemplateOptions = {}): string {
    Assert.exists(object);
    let mergedOptions = new DefaultInstantiateTemplateOptions().merge(instantiateOptions);
    object = _.extend({}, object, UnderscoreTemplate.templateHelpers);

    const templates = _.chain(TemplateCache.getDefaultTemplates())
      .map(name => TemplateCache.getTemplate(name))
      .value();

    // Put templates with conditions first
    const sortedTemplates = _.chain(templates)
      .sortBy(template => template.condition == null)
      .sortBy(template => template.fieldsToMatch == null)
      .value();

    for (let i = 0; i < sortedTemplates.length; i++) {
      const result = sortedTemplates[i].instantiateToString(object, mergedOptions);
      if (result != null) {
        return result;
      }
    }

    return this.getFallbackTemplate();
  }