public Nest.QueryContainer CreateNextPaginationFilter(Nest.QueryContainerDescriptor <ScoreRecord> q, ScoreRecord pivot)
        {
            // ( score < pivot.score) OR (score == pivot.score AND createdOn > pivot.createdOn)
            return(q.Bool(b1 => b1.Should(
                              q1 => q1.Range(r => r.Field(record => record.Score).LessThan(pivot.Score)),
                              q1 => q1.Bool(b2 => b2.Must(
                                                q2 => q2.Term(t => t.Field(record => record.Score).Value(pivot.Score)),
                                                q2 => q2.DateRange(r => r.Field(record => record.CreatedOn).GreaterThan(pivot.CreatedOn))
                                                ))

                              )));
        }
        private Nest.QueryContainer CreateQuery(
            Nest.QueryContainerDescriptor <ScoreRecord> desc,
            LeaderboardQuery rq,
            Func <Nest.QueryContainerDescriptor <ScoreRecord>, Nest.QueryContainer> additionalContraints = null)
        {
            return(desc.Bool(s2 =>
            {
                var mustClauses = Enumerable.Empty <Func <Nest.QueryContainerDescriptor <ScoreRecord>, Nest.QueryContainer> >();

                if (rq.FriendsIds.Any())
                {
                    mustClauses = mustClauses.Concat(new Func <Nest.QueryContainerDescriptor <ScoreRecord>, Nest.QueryContainer>[] {
                        q => q.Terms(t => t.Field(s => s.PlayerId).Terms(rq.FriendsIds.Select(i => i.ToString())))
                    });
                }
                if (rq.FieldFilters != null && rq.FieldFilters.Any())
                {
                    mustClauses = mustClauses.Concat(rq.FieldFilters.Select <FieldFilter, Func <Nest.QueryContainerDescriptor <ScoreRecord>, Nest.QueryContainer> >(f =>
                    {
                        return q => q.Term("document." + f.Field, f.Value);
                    }));
                }
                if (rq.ScoreFilters != null && rq.ScoreFilters.Any())
                {
                    mustClauses = mustClauses.Concat(rq.ScoreFilters.Select <ScoreFilter, Func <Nest.QueryContainerDescriptor <ScoreRecord>, Nest.QueryContainer> >(f =>
                    {
                        return q => q.Range(r =>
                        {
                            r = r.Field(s3 => s3.Score);
                            switch (f.Type)
                            {
                            case ScoreFilterType.GreaterThan:
                                r = r.GreaterThan(f.Value);
                                break;

                            case ScoreFilterType.GreaterThanOrEqual:
                                r = r.GreaterThanOrEquals(f.Value);
                                break;

                            case ScoreFilterType.LesserThan:
                                r = r.LessThan(f.Value);
                                break;

                            case ScoreFilterType.LesserThanOrEqual:
                                r = r.LessThanOrEquals(f.Value);
                                break;

                            default:
                                break;
                            }

                            return r;
                        });
                    }));
                }
                if (additionalContraints != null)
                {
                    mustClauses = mustClauses.Concat(new[] { additionalContraints });
                }
                return s2.Must(mustClauses);
            }));
        }