Example #1
0
        /// <inheritdoc />
        Task <LoginResponseModel> IAppUserEndPoint.Login(LoginRequestModel model)
        {
            var arguments = new object[] { model };
            var func      = requestBuilder.BuildRestResultFuncForMethod("Login", new Type[] { typeof(LoginRequestModel) });

            return((Task <LoginResponseModel>)func(Client, arguments));
        }
Example #2
0
        /// <inheritdoc />
        public virtual Task Post()
        {
            var arguments = new object[] {  };
            var func      = requestBuilder.BuildRestResultFuncForMethod("Post", new Type[] {  });

            return((Task)func(Client, arguments));
        }
Example #3
0
        /// <inheritdoc />
        Task <ApiResponse <ReqResApi> > ISingleUser.GetSingleUser()
        {
            var arguments = new object[] {  };
            var func      = requestBuilder.BuildRestResultFuncForMethod("GetSingleUser", new Type[] {  });

            return((Task <ApiResponse <ReqResApi> >)func(Client, arguments));
        }
Example #4
0
        /// <inheritdoc />
        Task <ApiResponse <string> > IListOfUsers.GetAllUsers(int page)
        {
            var arguments = new object[] { page };
            var func      = requestBuilder.BuildRestResultFuncForMethod("GetAllUsers", new Type[] { typeof(int) });

            return((Task <ApiResponse <string> >)func(Client, arguments));
        }
        /// <inheritdoc />
        Task <IActionResult> ICartServices.AddProduct(AddToCartRequest request)
        {
            var arguments = new object[] { request };
            var func      = requestBuilder.BuildRestResultFuncForMethod("AddProduct", new Type[] { typeof(AddToCartRequest) });

            return((Task <IActionResult>)func(Client, arguments));
        }
        /// <inheritdoc />
        Task <StockControlResponse> IStockServices.StockControl(long productId, int count)
        {
            var arguments = new object[] { productId, count };
            var func      = requestBuilder.BuildRestResultFuncForMethod("StockControl", new Type[] { typeof(long), typeof(int) });

            return((Task <StockControlResponse>)func(Client, arguments));
        }
        /// <inheritdoc />
        public virtual Task <EStatus> ConsultarStatusCirurgiao(string guid)
        {
            var arguments = new object[] { guid };
            var func      = requestBuilder.BuildRestResultFuncForMethod("ConsultarStatusCirurgiao", new Type[] { typeof(string) });

            return((Task <EStatus>)func(Client, arguments));
        }
        /// <inheritdoc />
        public virtual Task <SerieResponse> GetSeriesAsync(string apiKey)
        {
            var arguments = new object[] { apiKey };
            var func      = requestBuilder.BuildRestResultFuncForMethod("GetSeriesAsync", new Type[] { typeof(string) });

            return((Task <SerieResponse>)func(Client, arguments));
        }
Example #9
0
        /// <inheritdoc />
        public virtual Task <TestAliasObject> GetTestObject()
        {
            var arguments = new object[] {  };
            var func      = requestBuilder.BuildRestResultFuncForMethod("GetTestObject", new Type[] {  });

            return((Task <TestAliasObject>)func(Client, arguments));
        }
Example #10
0
        /// <inheritdoc />
        public virtual Task <RootObject> GetCongruence()
        {
            var arguments = new object[] {  };
            var func      = requestBuilder.BuildRestResultFuncForMethod("GetCongruence", new Type[] {  });

            return((Task <RootObject>)func(Client, arguments));
        }
Example #11
0
        /// <inheritdoc />
        public virtual Task <bool> PostAValue(string derp)
        {
            var arguments = new object[] { derp };
            var func      = requestBuilder.BuildRestResultFuncForMethod("PostAValue", new Type[] { typeof(string) });

            return((Task <bool>)func(Client, arguments));
        }
Example #12
0
        /// <inheritdoc />
        public virtual Task <string> GetWithDecimal(decimal value)
        {
            var arguments = new object[] { value };
            var func      = requestBuilder.BuildRestResultFuncForMethod("GetWithDecimal", new Type[] { typeof(decimal) });

            return((Task <string>)func(Client, arguments));
        }
        /// <inheritdoc />
        public virtual Task <SomeType> SomeRequest()
        {
            var arguments = new object[] {  };
            var func      = methodImpls.GetOrAdd("SomeRequest()", _ => requestBuilder.BuildRestResultFuncForMethod("SomeRequest", new Type[] {  }));

            return((Task <SomeType>)func(Client, arguments));
        }
        /// <inheritdoc />
        public virtual Task <TResponse> Get(TParam param, THeader header)
        {
            var arguments = new object[] { param, header };
            var func      = methodImpls.GetOrAdd("Get(TParam param,THeader header)", _ => requestBuilder.BuildRestResultFuncForMethod("Get", new Type[] { typeof(TParam), typeof(THeader) }));

            return((Task <TResponse>)func(Client, arguments));
        }
Example #15
0
        /// <inheritdoc />
        Task <CepResponse> ICepResponse.GetAddressAsync(String cep)
        {
            var arguments = new object[] { cep };
            var func      = requestBuilder.BuildRestResultFuncForMethod("GetAddressAsync", new Type[] { typeof(String) });

            return((Task <CepResponse>)func(Client, arguments));
        }
Example #16
0
 public AutoGeneratedTestNestedINestedGitHubApi(HttpClient client, IRequestBuilder requestBuilder)
 {
     Client = client;
     methodImpls.Add("GetUser(string userName)", requestBuilder.BuildRestResultFuncForMethod("GetUser", new Type[] { typeof(string) }));
     methodImpls.Add("GetUserObservable(string userName)", requestBuilder.BuildRestResultFuncForMethod("GetUserObservable", new Type[] { typeof(string) }));
     methodImpls.Add("GetUserCamelCase(string userName)", requestBuilder.BuildRestResultFuncForMethod("GetUserCamelCase", new Type[] { typeof(string) }));
     methodImpls.Add("GetOrgMembers(string orgName)", requestBuilder.BuildRestResultFuncForMethod("GetOrgMembers", new Type[] { typeof(string) }));
     methodImpls.Add("FindUsers(string q)", requestBuilder.BuildRestResultFuncForMethod("FindUsers", new Type[] { typeof(string) }));
     methodImpls.Add("GetIndex()", requestBuilder.BuildRestResultFuncForMethod("GetIndex", new Type[] {  }));
     methodImpls.Add("GetIndexObservable()", requestBuilder.BuildRestResultFuncForMethod("GetIndexObservable", new Type[] {  }));
     methodImpls.Add("NothingToSeeHere()", requestBuilder.BuildRestResultFuncForMethod("NothingToSeeHere", new Type[] {  }));
 }
Example #17
0
        /// <inheritdoc />
        public virtual Task <User> GetUser(string userName)
        {
            var arguments = new object[] { userName };
            var func      = methodImpls.GetOrAdd("GetUser(string userName)", _ => requestBuilder.BuildRestResultFuncForMethod("GetUser", new Type[] { typeof(string) }));

            return((Task <User>)func(Client, arguments));
        }
Example #18
0
        /// <inheritdoc />
        Task IStory.CreateStory(Story roomId)
        {
            var arguments = new object[] { roomId };
            var func      = requestBuilder.BuildRestResultFuncForMethod("CreateStory", new Type[] { typeof(Story) });

            return((Task)func(Client, arguments));
        }
Example #19
0
        /// <inheritdoc />
        Task <List <ModelApi> > IApiService.GetResponseAsync()
        {
            var arguments = new object[] {  };
            var func      = requestBuilder.BuildRestResultFuncForMethod("GetResponseAsync", new Type[] {  });

            return((Task <List <ModelApi> >)func(Client, arguments));
        }
Example #20
0
        public static Func <object[], HttpRequestMessage> BuildRequestFactoryForMethod(this IRequestBuilder builder, string methodName)
        {
            var factory = builder.BuildRestResultFuncForMethod(methodName);
            var testHttpMessageHandler = new TestHttpMessageHandler();


            return(paramList => {
                var task = (Task)factory(new HttpClient(testHttpMessageHandler)
                {
                    BaseAddress = new Uri("http://api/")
                }, paramList);
                task.Wait();
                return testHttpMessageHandler.RequestMessage;
            });
        }
Example #21
0
        public static Func <object[], TestHttpMessageHandler> RunRequest(this IRequestBuilder builder, string methodName, string returnContent = null)
        {
            var factory = builder.BuildRestResultFuncForMethod(methodName);
            var testHttpMessageHandler = new TestHttpMessageHandler();

            if (returnContent != null)
            {
                testHttpMessageHandler.Content = new StringContent(returnContent);
            }

            return(paramList => {
                var task = (Task)factory(new HttpClient(testHttpMessageHandler)
                {
                    BaseAddress = new Uri("http://api/")
                }, paramList);
                task.Wait();
                return testHttpMessageHandler;
            });
        }
Example #22
0
 public AutoGeneratedIGitHubApi(HttpClient client, IRequestBuilder requestBuilder)
 {
     methodImpls = requestBuilder.InterfaceHttpMethods.ToDictionary(k => k, v => requestBuilder.BuildRestResultFuncForMethod(v));
     Client      = client;
 }
Example #23
0
 public AutoGeneratedIAmARefitInterfaceButNobodyUsesMe(HttpClient client, IRequestBuilder requestBuilder)
 {
     methodImpls = requestBuilder.InterfaceHttpMethods.ToDictionary(k => k, v => requestBuilder.BuildRestResultFuncForMethod(v));
     Client      = client;
 }
        /// <inheritdoc />
        Task <List <ListOutlet> > IMyAPI.GetListChiNhanh()
        {
            var arguments = new object[] {  };
            var func      = requestBuilder.BuildRestResultFuncForMethod("GetListChiNhanh", new Type[] {  });

            return((Task <List <ListOutlet> >)func(Client, arguments));
        }
Example #25
0
        /// <inheritdoc />
        public virtual Task <HttpResponseMessage> UploadStream(Stream stream)
        {
            var arguments = new object[] { stream };
            var func      = requestBuilder.BuildRestResultFuncForMethod("UploadStream", new Type[] { typeof(Stream) });

            return((Task <HttpResponseMessage>)func(Client, arguments));
        }
Example #26
0
 public AutoGeneratedIProductsApi(HttpClient client, IRequestBuilder requestBuilder)
 {
     methodImpls = requestBuilder.InterfaceHttpMethods.ToDictionary(k => k, v => requestBuilder.BuildRestResultFuncForMethod(v));
     Client = client;
 }
 /// <inheritdoc />
 Task Program.ITrigramParserAPI.CreateTrigrams(RequestBody request)
 {
     var arguments = new object[] { request };
     var func = requestBuilder.BuildRestResultFuncForMethod("CreateTrigrams", new Type[] { typeof(RequestBody) });
     return (Task)func(Client, arguments);
 }
Example #28
0
        /// <inheritdoc />
        Task <List <Tareas> > RemoteService.GetAllTarea()
        {
            var arguments = new object[] {  };
            var func      = requestBuilder.BuildRestResultFuncForMethod("GetAllTarea", new Type[] {  });

            return((Task <List <Tareas> >)func(Client, arguments));
        }
Example #29
0
        /// <inheritdoc />
        public virtual Task PostMessage <T>(T message)
            where T : IMessage
        {
            var arguments = new object[] { message };
            var func      = methodImpls.GetOrAdd($"PostMessage<{typeof(T).AssemblyQualifiedName}>(T message)", _ => requestBuilder.BuildRestResultFuncForMethod("PostMessage", new Type[] { typeof(T) }, new Type[] { typeof(T) }));

            return((Task)func(Client, arguments));
        }
Example #30
0
        /// <inheritdoc />
        public virtual Task <HttpContent> PostFileUpload(HttpContent content)
        {
            var arguments = new object[] { content };
            var func      = methodImpls.GetOrAdd("PostFileUpload(HttpContent content)", _ => requestBuilder.BuildRestResultFuncForMethod("PostFileUpload", new Type[] { typeof(HttpContent) }));

            return((Task <HttpContent>)func(Client, arguments));
        }
Example #31
0
        /// <inheritdoc />
        public virtual Task <Stream> GetRemoteFile(string filename)
        {
            var arguments = new object[] { filename };
            var func      = methodImpls.GetOrAdd("GetRemoteFile(string filename)", _ => requestBuilder.BuildRestResultFuncForMethod("GetRemoteFile", new Type[] { typeof(string) }));

            return((Task <Stream>)func(Client, arguments));
        }