示例#1
0
 private object ExecuteWithClientSelectPart <TServer, TClient>(string uri,
                                                               RestQueryableTreeParser.QueryProjection
                                                               queryProjection,
                                                               Expression <Func <TServer, TClient> >
                                                               clientSideExpression,
                                                               RequestOptions requestOptions,
                                                               bool executeAsync)
 {
     return(Execute(uri, queryProjection, clientSideExpression.Compile(), requestOptions, executeAsync));
 }
示例#2
0
        private object Execute <T, TConverted>(string uri,
                                               RestQueryableTreeParser.QueryProjection queryProjection,
                                               Func <T, TConverted> clientSideSelectPart,
                                               RequestOptions requestOptions,
                                               bool executeAsync)
        {
            if (executeAsync)
            {
                return(ExecuteAsync(uri, queryProjection, clientSideSelectPart, requestOptions));
            }

            ;
            return(ExecuteSync(uri, queryProjection, clientSideSelectPart, requestOptions));
        }
示例#3
0
        private object ExecuteAsync <T, TConverted>(string uri,
                                                    RestQueryableTreeParser.QueryProjection queryProjection,
                                                    Func <T, TConverted> clientSideSelectPart,
                                                    RequestOptions requestOptions)
        {
            if (queryProjection == RestQueryableTreeParser.QueryProjection.FirstLazy)
            {
                throw new InvalidOperationException("Don't use FirstLazy when executing async as this is redundant.");
            }

            switch (queryProjection)
            {
            case RestQueryableTreeParser.QueryProjection.ToQueryResult:
                return(ExecuteToQueryResultAsync(uri, clientSideSelectPart, requestOptions));

            case RestQueryableTreeParser.QueryProjection.Enumerable:
                return(ExecuteToEnumerableAsync(uri, clientSideSelectPart, requestOptions));

            case RestQueryableTreeParser.QueryProjection.SingleOrDefault:
            case RestQueryableTreeParser.QueryProjection.First:
            case RestQueryableTreeParser.QueryProjection.FirstOrDefault:
            case RestQueryableTreeParser.QueryProjection.Single:
            case RestQueryableTreeParser.QueryProjection.Last:
            case RestQueryableTreeParser.QueryProjection.LastOrDefault:
                return(GetOneAsync(uri, requestOptions, clientSideSelectPart));

            case RestQueryableTreeParser.QueryProjection.Any:
            case RestQueryableTreeParser.QueryProjection.Max:
            case RestQueryableTreeParser.QueryProjection.Min:
            case RestQueryableTreeParser.QueryProjection.Sum:
            case RestQueryableTreeParser.QueryProjection.Count:
                return(Client.GetAsync <TConverted>(uri, requestOptions));

            default:
                throw new NotImplementedException("Don't recognize projection type " + queryProjection);
            }
        }
示例#4
0
        private object ExecuteSync <T, TConverted>(string uri,
                                                   RestQueryableTreeParser.QueryProjection queryProjection,
                                                   Func <T, TConverted> clientSideSelectPart,
                                                   RequestOptions requestOptions)
        {
            if (queryProjection == RestQueryableTreeParser.QueryProjection.FirstLazy)
            {
                var resourceLoader = requestOptions == null || requestOptions.ResourceLoader == null
                    ? new DefaultResourceLoader(Client)
                    : requestOptions.ResourceLoader;

                var resourceInfo = Client.GetResourceInfoForType(typeof(T));
                var proxy        = (LazyProxyBase)Activator.CreateInstance(resourceInfo.LazyProxyType);
                proxy.Initialize(uri, resourceLoader, resourceInfo.PocoType);
                return(proxy);
            }

            switch (queryProjection)
            {
            case RestQueryableTreeParser.QueryProjection.ToQueryResult:
            {
                var result = Client.Get <QueryResult <T> >(uri, requestOptions);
                if (clientSideSelectPart != null)
                {
                    return(new QueryResult <TConverted>(result.Select(clientSideSelectPart), result.Skip, result.TotalCount,
                                                        result.Previous,
                                                        result.Next));
                }
                return(result);
            }

            case RestQueryableTreeParser.QueryProjection.Enumerable:
            {
                var result = Client.Get <IList <T> >(uri, requestOptions);
                if (clientSideSelectPart != null)
                {
                    return(result.Select(clientSideSelectPart).ToList());
                }
                return(result);
            }

            case RestQueryableTreeParser.QueryProjection.SingleOrDefault:
            case RestQueryableTreeParser.QueryProjection.First:
            case RestQueryableTreeParser.QueryProjection.FirstOrDefault:
            case RestQueryableTreeParser.QueryProjection.Single:
            case RestQueryableTreeParser.QueryProjection.Last:
            case RestQueryableTreeParser.QueryProjection.LastOrDefault:
                return(GetOne(uri, requestOptions, clientSideSelectPart));

            case RestQueryableTreeParser.QueryProjection.Any:
                // TODO: Remove backwards compatibility at some point in the future.
                // HACK for backwards compatibility. Any is not supported by old versions of pomona server
                return(Client.Get <int>(uri, requestOptions) > 0);

            case RestQueryableTreeParser.QueryProjection.Max:
            case RestQueryableTreeParser.QueryProjection.Min:
            case RestQueryableTreeParser.QueryProjection.Sum:
            case RestQueryableTreeParser.QueryProjection.Count:
                return(Client.Get <T>(uri, requestOptions));

            default:
                throw new NotImplementedException("Don't recognize projection type " + queryProjection);
            }
        }