public virtual GenericSearchResult <DerivativeContract> SearchDerivativeContracts(DerivativeContractSearchCriteria criteria)
        {
            using (var repository = _repositoryFactory())
            {
                repository.DisableChangesTracking();

                var query = repository.DerivativeContracts;

                if (!criteria.MemberIds.IsNullOrEmpty())
                {
                    query = query.Where(dc => criteria.MemberIds.Contains(dc.MemberId));
                }

                if (!criteria.Types.IsNullOrEmpty())
                {
                    var criteriaTypes = criteria.Types.Select(x => x.ToString()).ToArray();
                    query = query.Where(dc => criteriaTypes.Contains(dc.Type));
                }

                if (criteria.OnlyActive)
                {
                    var now = DateTime.Now;
                    query = query.Where(dc => dc.IsActive && dc.StartDate <= now && (dc.EndDate == null || dc.EndDate >= now) && dc.Items.Any(dci => dci.RemainingQuantity > 0));
                }

                if (criteria.OnlyRemaining)
                {
                    query = query.Where(dc => dc.IsActive && dc.Items.Any(dci => dci.RemainingQuantity > 0));
                }

                var predicate = GetQueryPredicate(criteria);
                query = query.Where(predicate.Expand());

                var sortInfos = criteria.SortInfos;
                if (sortInfos.IsNullOrEmpty())
                {
                    sortInfos = new[]
                    {
                        new SortInfo {
                            SortColumn = "StartDate", SortDirection = SortDirection.Descending
                        },
                        new SortInfo {
                            SortColumn = "EndDate", SortDirection = SortDirection.Ascending
                        }
                    };
                }
                query = query.OrderBySortInfos(sortInfos);

                var totalCount            = query.Count();
                var derivativeContractIds = query.Select(dc => dc.Id).Skip(criteria.Skip).Take(criteria.Take).ToArray();

                return(new GenericSearchResult <DerivativeContract>
                {
                    Results = _derivativeContractService.GetDerivativeContractsByIds(derivativeContractIds).OrderBy(dc => dc.Id).ToList(),
                    TotalCount = totalCount
                });
            }
        }
        public IHttpActionResult Search(DerivativeContractSearchCriteria criteria)
        {
            var result = _derivativeContractSearchService.SearchDerivativeContracts(criteria);

            return(Ok(result));
        }
        /// <summary>
        /// Used to define extra where clause for derivative contracts search
        /// </summary>
        /// <param name="criteria"></param>
        /// <returns></returns>
        protected virtual Expression <Func <DerivativeContractEntity, bool> > GetQueryPredicate(DerivativeContractSearchCriteria criteria)
        {
            if (!criteria.StartDateRanges.IsNullOrEmpty() || !criteria.EndDateRanges.IsNullOrEmpty())
            {
                var predicate = PredicateBuilder.False <DerivativeContractEntity>();
                if (!criteria.StartDateRanges.IsNullOrEmpty())
                {
                    predicate = PredicateBuilder.Or(predicate, ((Expression <Func <DerivativeContractEntity, DateTime?> >)(dci => dci.StartDate)).IsInRanges(criteria.StartDateRanges));
                }

                if (!criteria.EndDateRanges.IsNullOrEmpty())
                {
                    predicate = PredicateBuilder.Or(predicate, ((Expression <Func <DerivativeContractEntity, DateTime?> >)(dci => dci.EndDate)).IsInRanges(criteria.EndDateRanges));
                }
                return(predicate.Expand());
            }
            return(PredicateBuilder.True <DerivativeContractEntity>());
        }