public Task <SearchSCIMRepresentationsResponse> FindSCIMRepresentations(SearchSCIMRepresentationsParameter parameter)
        {
            var queryableRepresentations = _representations.AsQueryable().Where(r => r.ResourceType == parameter.ResourceType);

            if (parameter.Filter != null)
            {
                var evaluatedExpression = parameter.Filter.Evaluate(queryableRepresentations);
                queryableRepresentations = (IQueryable <SCIMRepresentation>)evaluatedExpression.Compile().DynamicInvoke(queryableRepresentations);
            }

            if (parameter.SortBy != null)
            {
                var evaluatedExpression = parameter.SortBy.Evaluate(queryableRepresentations);
                var ordered             = (IEnumerable <SCIMRepresentation>)evaluatedExpression.Compile().DynamicInvoke(queryableRepresentations);
                queryableRepresentations = ordered.ToList().AsQueryable();
            }

            int totalResults = queryableRepresentations.Count();
            IEnumerable <SCIMRepresentation> result = new List <SCIMRepresentation>();

            if (parameter.Count > 0)
            {
                result = queryableRepresentations.Skip(parameter.StartIndex).Take(parameter.Count).ToList();
            }

            return(Task.FromResult(new SearchSCIMRepresentationsResponse(totalResults, result)));
        }
Beispiel #2
0
        public Task <SearchSCIMRepresentationsResponse> FindSCIMRepresentations(SearchSCIMRepresentationsParameter parameter)
        {
            IEnumerable <SCIMRepresentation> result = null;
            int totalResults             = 0;
            var collection               = _scimDbContext.SCIMRepresentationLst;
            var queryableRepresentations = collection.AsQueryable().Where(s => s.ResourceType == parameter.ResourceType);

            if (parameter.Filter != null)
            {
                var evaluatedExpression = parameter.Filter.Evaluate(queryableRepresentations);
                var filtered            = evaluatedExpression.Compile().DynamicInvoke(queryableRepresentations) as IMongoQueryable <SCIMRepresentation>;
                totalResults = filtered.Count();
                var representations = filtered.Skip(parameter.StartIndex <= 1 ? 0 : parameter.StartIndex - 1).Take(parameter.Count);
                result = representations.ToList();
            }
            else
            {
                totalResults = queryableRepresentations.Count();
                var representations = queryableRepresentations.Skip(parameter.StartIndex <= 1 ? 0 : parameter.StartIndex - 1).Take(parameter.Count);
                result = representations.ToList().Cast <SCIMRepresentation>();
            }

            result.FilterAttributes(parameter.IncludedAttributes, parameter.ExcludedAttributes);
            return(Task.FromResult(new SearchSCIMRepresentationsResponse(totalResults, result)));
        }
Beispiel #3
0
        public Task <SearchSCIMRepresentationsResponse> FindSCIMRepresentations(SearchSCIMRepresentationsParameter parameter)
        {
            IQueryable <SCIMRepresentation> queryableRepresentations = _scimDbContext.SCIMRepresentationLst;

            if (parameter.Filter != null)
            {
                var evaluatedExpression = parameter.Filter.Evaluate(queryableRepresentations);
                queryableRepresentations = (IQueryable <SCIMRepresentation>)evaluatedExpression.Compile().DynamicInvoke(queryableRepresentations);
            }

            int totalResults = queryableRepresentations.Count();

            return(Task.FromResult(new SearchSCIMRepresentationsResponse(totalResults, queryableRepresentations.Skip(parameter.StartIndex).Take(parameter.Count).ToList())));
        }
        public Task <SearchSCIMRepresentationsResponse> FindSCIMRepresentations(SearchSCIMRepresentationsParameter parameter)
        {
            IQueryable <SCIMRepresentationModel> queryableRepresentations = IncludeRepresentationNavigationProperties(_scimDbContext.SCIMRepresentationLst)
                                                                            .Where(s => s.ResourceType == parameter.ResourceType);

            if (parameter.Filter != null)
            {
                var evaluatedExpression = parameter.Filter.Evaluate(queryableRepresentations);
                queryableRepresentations = (IQueryable <SCIMRepresentationModel>)evaluatedExpression.Compile().DynamicInvoke(queryableRepresentations);
            }

            int totalResults = queryableRepresentations.Count();
            var result       = queryableRepresentations.Skip(parameter.StartIndex).Take(parameter.Count).ToList().Select(s => s.ToDomain());

            return(Task.FromResult(new SearchSCIMRepresentationsResponse(totalResults, result)));
        }
        public Task <SearchSCIMRepresentationsResponse> FindSCIMRepresentations(SearchSCIMRepresentationsParameter parameter)
        {
            var collection = _scimDbContext.SCIMRepresentationLst;
            var queryableRepresentations = collection.AsQueryable().Where(s => s.ResourceType == parameter.ResourceType);

            if (parameter.Filter != null)
            {
                var evaluatedExpression = parameter.Filter.Evaluate(queryableRepresentations);
                queryableRepresentations = (IQueryable <SCIMRepresentationModel>)evaluatedExpression.Compile().DynamicInvoke(queryableRepresentations);
            }

            int totalResults = queryableRepresentations.Count();
            IEnumerable <SCIMRepresentation> result = new List <SCIMRepresentation>();

            if (parameter.Count > 0)
            {
                result = queryableRepresentations.Skip(parameter.StartIndex).Take(parameter.Count).ToList().Select(s => s.ToDomain(_scimDbContext.Database));
            }

            return(Task.FromResult(new SearchSCIMRepresentationsResponse(totalResults, result)));
        }
Beispiel #6
0
        public async Task <SearchSCIMRepresentationsResponse> FindSCIMRepresentations(SearchSCIMRepresentationsParameter parameter)
        {
            IQueryable <SCIMRepresentation> queryableRepresentations = _scimDbContext.SCIMRepresentationLst
                                                                       .Include(r => r.FlatAttributes)
                                                                       .Where(s => s.ResourceType == parameter.ResourceType);

            if (parameter.SortBy == null)
            {
                queryableRepresentations = queryableRepresentations.OrderBy(s => s.Id);
            }

            if (parameter.Filter != null)
            {
                var evaluatedExpression = parameter.Filter.Evaluate(queryableRepresentations);
                queryableRepresentations = (IQueryable <SCIMRepresentation>)evaluatedExpression.Compile().DynamicInvoke(queryableRepresentations);
            }

            if (parameter.SortBy != null)
            {
                return(await parameter.SortBy.EvaluateOrderBy(
                           _scimDbContext,
                           queryableRepresentations,
                           parameter.SortOrder.Value,
                           parameter.StartIndex,
                           parameter.Count,
                           parameter.IncludedAttributes,
                           parameter.ExcludedAttributes));
            }

            int total = queryableRepresentations.Count();

            queryableRepresentations = queryableRepresentations.Skip(parameter.StartIndex <= 1 ? 0 : parameter.StartIndex - 1).Take(parameter.Count);
            return(queryableRepresentations.BuildResult(_scimDbContext, parameter.IncludedAttributes, parameter.ExcludedAttributes, total));
        }
        public async Task <SearchSCIMRepresentationsResponse> FindSCIMRepresentations(SearchSCIMRepresentationsParameter parameter)
        {
            IQueryable <SCIMRepresentationModel> queryableRepresentations = _scimDbContext.SCIMRepresentationLst
                                                                            .Where(s => s.ResourceType == parameter.ResourceType);

            if (parameter.SortBy == null)
            {
                queryableRepresentations = queryableRepresentations.OrderBy(s => s.Id);
            }

            if (parameter.Filter != null)
            {
                var evaluatedExpression = parameter.Filter.Evaluate(queryableRepresentations);
                queryableRepresentations = (IQueryable <SCIMRepresentationModel>)evaluatedExpression.Compile().DynamicInvoke(queryableRepresentations);
            }

            if (parameter.SortBy != null)
            {
                return(await parameter.SortBy.EvaluateOrderBy(
                           _scimDbContext,
                           queryableRepresentations,
                           parameter.SortOrder.Value,
                           parameter.StartIndex,
                           parameter.Count,
                           CancellationToken.None));
            }

            int totalResults = queryableRepresentations.Count();
            IEnumerable <SCIMRepresentation> result = queryableRepresentations.Skip(parameter.StartIndex).Take(parameter.Count).ToList().Select(s => s.ToDomain());

            return(new SearchSCIMRepresentationsResponse(totalResults, result));
        }