private HttpMethod GetHttpMethod(WebRequestMethod method) { switch (Method) { case WebRequestMethod.Default: case WebRequestMethod.Get: return(HttpMethod.Get); case WebRequestMethod.Head: return(HttpMethod.Head); case WebRequestMethod.Post: return(HttpMethod.Post); case WebRequestMethod.Put: return(HttpMethod.Put); case WebRequestMethod.Delete: return(HttpMethod.Delete); case WebRequestMethod.Trace: return(HttpMethod.Trace); case WebRequestMethod.Options: return(HttpMethod.Options); default: // Merge and Patch return(new HttpMethod(Method.ToString().ToUpperInvariant())); } }
public static Collection <PSObject> InvokeRestCommand( this CommandInvocationIntrinsics commandInvocation, Uri uri, WebRequestMethod method, object body, IDictionary headers ) { var powershellParams = new Dictionary <object, object> { { nameof(uri), uri }, { nameof(method), method }, { nameof(body), body }, { nameof(headers), headers } }; var paramString = GeneralUtils.FormatPowerShellParams(powershellParams); var scriptBlock = $"Invoke-RestMethod {paramString}"; return(commandInvocation.InvokeScript( scriptBlock, false, System.Management.Automation.Runspaces.PipelineResultTypes.Output, null, null )); }
public static string SendRequest(string url, WebRequestMethod method = WebRequestMethod.Get, Dictionary <string, string> headers = null, byte[] body = null, string contentType = "", int timeout = 5000) { Dictionary <string, string> responseHeaders; return(SendRequest(url, out responseHeaders, method, headers, body, contentType, timeout)); }
private static HttpWebRequest MakeRequest(string url, WebRequestMethod method = WebRequestMethod.Get, Dictionary <string, string> headers = null, byte[] body = null, string contentType = "", int timeout = 5000) { var request = (HttpWebRequest)WebRequest.Create(url); request.Method = method.ToString().ToUpperInvariant(); request.ContentType = contentType; request.UserAgent = "BinarySundial"; request.Timeout = timeout; if (headers != null) { foreach (var header in headers) { request.Headers.Add(header.Key, header.Value); } } if ((method == WebRequestMethod.Post || method == WebRequestMethod.Patch) && body != null) { request.ContentType = contentType; request.ContentLength = body.Length; using (var stream = request.GetRequestStream()) stream.Write(body, 0, body.Length); } return(request); }
static string Execute(WebClient client, string address, WebRequestMethod method, string data, bool throwError, out ErrorResultTO errors) { EnsureContentType(client); errors = new ErrorResultTO(); try { switch (method) { case WebRequestMethod.Get: return(FixResponse(client.DownloadString(address))); default: return(FixResponse(client.UploadString(address, method.ToString().ToUpperInvariant(), data))); } } catch (Exception e) { errors.AddError(e.Message); if (throwError) { throw; } } finally { // clean up client ;) client.Dispose(); } return(string.Empty); }
/// <summary> /// /// </summary> /// <param name="uri"></param> /// <param name="requestMethod"></param> /// <param name="isAsync"></param> /// <returns></returns> protected WebRequestContext CreateRequestContext(Uri uri, WebRequestMethod requestMethod, bool isAsync = false) { var _request = CreateRequest(uri, requestMethod); var _context = new WebRequestContext(_request, requestMethod, isAsync); return(_context); }
/// <summary> /// /// </summary> /// <param name="request"></param> /// <param name="requestMethod"></param> /// <param name="bufferSize"></param> /// <param name="sourceStream"></param> /// <param name="isAsync"></param> public WebRequestContext(WebRequest request, WebRequestMethod requestMethod, int bufferSize, FileStream sourceStream, bool isAsync) : this(request, requestMethod, isAsync) { _bufferSize = bufferSize; _sourceStream = sourceStream; _contentLength = sourceStream.Length; }
private async void SendAsync(string methodName, string url) { WebRequestMethod method = WebRequestUtility.GetMethod(methodName); var request = new WebRequest(method, url); await OnSendAsync(request); }
/// <summary> /// /// </summary> /// <param name="uri"></param> /// <param name="requestMethod"></param> /// <param name="bufferSize"></param> /// <param name="destinationStream"></param> /// <param name="contentLength"></param> /// <param name="isAsync"></param> /// <returns></returns> protected WebRequestContext CreateRequestContext(Uri uri, WebRequestMethod requestMethod, int bufferSize, FileStream destinationStream, long contentLength, bool isAsync = false) { var _request = CreateRequest(uri, requestMethod); var _context = new WebRequestContext(_request, requestMethod, bufferSize, destinationStream, contentLength, isAsync); return(_context); }
/// <summary> /// /// </summary> /// <param name="uri"></param> /// <param name="requestMethod"></param> /// <param name="bufferSize"></param> /// <param name="sourceStream"></param> /// <param name="contentLength"></param> /// <returns></returns> protected WebRequestContext CreateRequestContext(Uri uri, WebRequestMethod requestMethod, int bufferSize, FileStream sourceStream, bool isAsync = false) { var _request = CreateRequest(uri, requestMethod); var _context = new WebRequestContext(_request, requestMethod, bufferSize, sourceStream, isAsync); _byteBuffer = new byte[bufferSize]; return(_context); }
public MARIAWebRequest(string URL, WebRequestMethod Method, ref HttpClient Client) { this.URL = URL; this.QueryStringParameters = new Dictionary <string, string>(); this.PostParameters = new Dictionary <string, string>(); this.PostObjects = new Dictionary <string, object>(); this.Client = Client; this.RequestDelay = 0; }
public static WebRequestDataDto CreateRequestDataDto(WebRequestMethod requestMethod, InArgument <string> type, string displayName) { return(new WebRequestDataDto() { WebRequestMethod = requestMethod, DisplayName = displayName, Type = type }); }
string DummyWebExecute(WebSource source, WebRequestMethod method, string relativeUri, string data, bool throwError, out ErrorResultTO errors, string[] headers) { _requestUrlEvaluated = relativeUri; _requestBodyEvaluated = data; _requestHeadersEvaluated = headers; errors = new ErrorResultTO(); return(_requestResponse); }
public WebRequest(Dictionary <string, string> headers, WebRequestMethod method, string url) : base(headers) { if (string.IsNullOrEmpty(url)) { throw new ArgumentException("Value cannot be null or empty.", nameof(url)); } Method = method; Url = url; }
/// <summary> /// /// </summary> /// <param name="uri"></param> /// <param name="method"></param> /// <returns></returns> protected virtual WebRequest CreateRequest(Uri uri, WebRequestMethod requestMethod) { var _request = FtpWebRequest.Create(uri) as FtpWebRequest; _request.KeepAlive = true; _request.UsePassive = false; _request.Method = WebRequestHelpers.WebRequestMethodToFtpMethodString(requestMethod); _request.Credentials = FileService.Credential; return(_request); }
public static WebRequest CreateRequest(string url, WebRequestMethod method = WebRequestMethod.GET, WebHeaderCollection headers = null, string payload = "") { return(new WebRequest { URL = url, Method = method, Headers = headers, Payload = payload, ContentType = ContentType.Json }); }
/// <summary> /// /// </summary> /// <param name="response"></param> /// <param name="requestMethod"></param> /// <returns></returns> protected virtual IExternalResult GetRequestResult(WebResponse response, WebRequestMethod requestMethod) { var _response = response as FtpWebResponse; if (null != _response) { switch (requestMethod) { case WebRequestMethod.MakeDirectory: if (_response.StatusCode.Equals(FtpStatusCode.PathnameCreated)) { return(new OperationResult(_response.StatusDescription, 0)); } break; case WebRequestMethod.ExistDirectory: if (_response.StatusCode.Equals(FtpStatusCode.DataAlreadyOpen)) { return(new OperationResult(_response.StatusDescription, 0)); } break; case WebRequestMethod.ExistFile: if (_response.StatusCode.Equals(FtpStatusCode.FileStatus)) { return(new OperationResult(_response.StatusDescription, 0)); } break; case WebRequestMethod.UploadFile: case WebRequestMethod.DownloadFile: if (_response.StatusCode.Equals(FtpStatusCode.ClosingData)) { return(new OperationResult(_response.StatusDescription, 0)); } break; default: throw new NotSupportedException(string.Format("The '{0}' method is not supported.", requestMethod)); } } throw new NullReferenceException("The response cannot be null."); }
public static WebRequest CreateMultipartRequest(string url, WebRequestMethod method = WebRequestMethod.GET, WebHeaderCollection headers = null, NameValueCollection values = null, string filepath = "", string filename = "") { return(new WebRequest { URL = url, Method = method, Headers = headers, Values = values, FilePath = filepath, FileName = filename, ContentType = ContentType.Multipart }); }
// ReSharper disable UnusedParameter.Local static byte[] Execute(WebClient client, string address, WebRequestMethod method, byte[] data, bool throwError, out ErrorResultTO errors) // ReSharper restore UnusedParameter.Local { EnsureContentType(client); errors = new ErrorResultTO(); switch (method) { case WebRequestMethod.Get: return(client.DownloadData(address)); default: return(client.UploadData(address, method.ToString().ToUpperInvariant(), data)); } }
public static Collection <PSObject> InvokeRestCommand( this PSCmdlet caller, Uri uri, WebRequestMethod method, object body, IDictionary headers ) { return(caller.InvokeCommand.InvokeRestCommand( uri, method, body, headers )); }
/// <summary> /// /// </summary> /// <param name="requestMethod"></param> /// <returns></returns> public static string WebRequestMethodToFtpMethodString(WebRequestMethod requestMethod) { switch (requestMethod) { case WebRequestMethod.AppendFile: return(WebRequestMethods.Ftp.AppendFile); case WebRequestMethod.DeleteFile: return(WebRequestMethods.Ftp.DeleteFile); case WebRequestMethod.DownloadFile: return(WebRequestMethods.Ftp.DownloadFile); case WebRequestMethod.GetDateTimestamp: return(WebRequestMethods.Ftp.GetDateTimestamp); case WebRequestMethod.ExistFile: case WebRequestMethod.GetFileSize: return(WebRequestMethods.Ftp.GetFileSize); case WebRequestMethod.ListDirectory: case WebRequestMethod.ExistDirectory: return(WebRequestMethods.Ftp.ListDirectory); case WebRequestMethod.ListDirectoryDetails: return(WebRequestMethods.Ftp.ListDirectoryDetails); case WebRequestMethod.MakeDirectory: return(WebRequestMethods.Ftp.MakeDirectory); case WebRequestMethod.PrintWorkingDirectory: return(WebRequestMethods.Ftp.PrintWorkingDirectory); case WebRequestMethod.RemoveDirectory: return(WebRequestMethods.Ftp.RemoveDirectory); case WebRequestMethod.Rename: return(WebRequestMethods.Ftp.Rename); case WebRequestMethod.UploadFile: return(WebRequestMethods.Ftp.UploadFile); case WebRequestMethod.UploadFileWithUniqueName: return(WebRequestMethods.Ftp.UploadFileWithUniqueName); } return(null); }
private async Task <HttpResponseMessage> GetResponse(string endpointName, WebRequestMethod requestMethod, CancellationToken cts, object data) { client = GetClient($"{App.ApiUrl}/{endpointName}"); switch (requestMethod) { case WebRequestMethod.DELETE: return(await client.DeleteAsync(string.Empty, cts)); case WebRequestMethod.GET: return(await client.GetAsync(string.Empty, cts).ConfigureAwait(true)); case WebRequestMethod.POST: return(await client.PostAsync(string.Empty, new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json"), cts)); case WebRequestMethod.PUT: return(await client.PutAsync(string.Empty, new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json"), cts)); default: throw new ArgumentOutOfRangeException(); } }
static string Execute(WebClient client, string address, WebRequestMethod method, string data, bool throwError, out ErrorResultTO errors) { EnsureContentType(client); if (method == WebRequestMethod.Put) { if (data != null) { var deserializeObject = JsonConvert.DeserializeObject(data); if (deserializeObject != null) { client.Headers["Content-Type"] = "application/json"; } } } errors = new ErrorResultTO(); try { switch (method) { case WebRequestMethod.Get: return(FixResponse(client.DownloadString(address))); default: return(FixResponse(client.UploadString(address, method.ToString().ToUpperInvariant(), data))); } } catch (Exception e) { errors.AddError(e.Message); if (throwError) { throw; } } finally { // clean up client ;) client.Dispose(); } return(string.Empty); }
public static T SendJsonRequest <T>(string url, out Dictionary <string, string> responseHeaders, WebRequestMethod method = WebRequestMethod.Get, Dictionary <string, string> headers = null, byte[] body = null, string contentType = "", int timeout = 5000) { var request = MakeRequest(url, method, headers, body, contentType, timeout); T result; responseHeaders = new Dictionary <string, string>(); using (var response = request.GetResponse()) { result = JsonSerializer.DeserializeResponse <T>(response); foreach (var header in response.Headers) { var key = (string)header; responseHeaders.Add(key, response.Headers[key]); } } return(result); }
private async Task <Response <T> > GetResponse <T>(string endpointName, WebRequestMethod requestMethod, CancellationToken cts, object data) { var result = new Response <T>(); using (var response = await GetResponse(endpointName, requestMethod, cts, data)) { var responseString = await response.Content.ReadAsStringAsync().ConfigureAwait(false); if (responseString == "[]" && !typeof(IEnumerable).GetTypeInfo().IsAssignableFrom(typeof(T).GetTypeInfo())) { result.Data = default(T); } else { result.Data = JsonConvert.DeserializeObject <T>(responseString); } responseString = null; return(result); } }
public static Stream GetStreamFromRequest(string url, out Dictionary <string, string> responseHeaders, WebRequestMethod method = WebRequestMethod.Get, Dictionary <string, string> headers = null, byte[] body = null, string contentType = "", int timeout = 5000) { var request = MakeRequest(url, method, headers, body, contentType, timeout); string responseString = String.Empty; responseHeaders = new Dictionary <string, string>(); var response = request.GetResponse(); var stream = response.GetResponseStream(); var reader = new StreamReader(stream); foreach (var header in response.Headers) { var key = (string)header; responseHeaders.Add(key, response.Headers[key]); } return(stream); }
public static string GetMethodName(WebRequestMethod method) { switch (method) { case WebRequestMethod.Create: return("CREATE"); case WebRequestMethod.Delete: return("DELETE"); case WebRequestMethod.Get: return("GET"); case WebRequestMethod.Head: return("HEAD"); case WebRequestMethod.Post: return("POST"); case WebRequestMethod.Put: return("PUT"); default: { throw new ArgumentOutOfRangeException(nameof(method), method, "Unknown method specified."); } } }
private HttpMethod GetHttpMethod(WebRequestMethod method) { switch (Method) { case WebRequestMethod.Default: case WebRequestMethod.Get: return HttpMethod.Get; case WebRequestMethod.Head: return HttpMethod.Head; case WebRequestMethod.Post: return HttpMethod.Post; case WebRequestMethod.Put: return HttpMethod.Put; case WebRequestMethod.Delete: return HttpMethod.Delete; case WebRequestMethod.Trace: return HttpMethod.Trace; case WebRequestMethod.Options: return HttpMethod.Options; default: // Merge and Patch return new HttpMethod(Method.ToString().ToUpperInvariant()); } }
protected virtual async Task <IWebRequest> OnCreateRequestAsync(HttpListenerContext context) { HttpListenerRequest listenerRequest = context.Request; WebRequestMethod method = WebRequestUtility.GetMethod(listenerRequest.HttpMethod); var request = new WebRequest(method, listenerRequest.RawUrl); foreach (string key in listenerRequest.Headers.AllKeys) { string value = listenerRequest.Headers.Get(key); request.Headers.Add(key, value); } if (listenerRequest.HasEntityBody) { await using var memoryStream = new MemoryStream(); await listenerRequest.InputStream.CopyToAsync(memoryStream); byte[] bytes = memoryStream.ToArray(); if (bytes.Length > 0) { request.SetData(bytes); } } Log.Debug("Received web request", new { request.Method, request.Url, request.HasData }); return(request); }
/// <summary> /// 執行後回初始值 /// </summary> private void AfterReset() { this._method = WebRequestMethod.Get; this._webTimeout = 20 * 1000; this._webContentType = "application/x-www-form-urlencoded"; }
/// <summary> /// This method will try to login to a http and html based application /// </summary> /// <param name="_host">The host of the web application</param> /// <param name="_postParamters">The post parameters of the request. Almost contains username and password</param> /// <param name="_webRequestMethod">GET or POST Method</param> /// <param name="_encoding">Encodig type. In most cases it is recommended to use 'Encoding.Default'</param> /// <returns> /// Returns the result of the request in form of a html page. It is hard to check if the login was successfull even /// you don't know what should get compared with. So you have to do it yourself^^ /// </returns> public HtmlDocument loginToServer(Uri _host, IList<HTTPParameter> _postParamters, WebRequestMethod _webRequestMethod, Encoding _encoding) { return this.getHTML(_host, null, _postParamters, _encoding); }
public static byte[] Execute(WebSource source, WebRequestMethod method, string relativeUri, byte[] data, bool throwError, out ErrorResultTO errors, string[] headers = null) { EnsureWebClient(source, headers); return(Execute(source.Client, GetAddress(source, relativeUri), method, data, throwError, out errors)); }
string DummyWebExecute(WebSource source, WebRequestMethod method, string relativeUri, string data, bool throwError, out ErrorResultTO errors, string[] headers) { _requestUrlEvaluated = relativeUri; _requestBodyEvaluated = data; _requestHeadersEvaluated = headers; errors = new ErrorResultTO(); return _requestResponse; }
public static byte[] Execute(WebSource source, WebRequestMethod method, string relativeUri, byte[] data, bool throwError, out ErrorResultTO errors, string[] headers = null) { EnsureWebClient(source, headers); return Execute(source.Client, string.Format("{0}{1}", source.Address, relativeUri), method, data, throwError, out errors); }
// ReSharper disable UnusedParameter.Local static byte[] Execute(WebClient client, string address, WebRequestMethod method, byte[] data, bool throwError, out ErrorResultTO errors) // ReSharper restore UnusedParameter.Local { EnsureContentType(client); errors = new ErrorResultTO(); switch(method) { case WebRequestMethod.Get: return client.DownloadData(address); default: return client.UploadData(address, method.ToString().ToUpperInvariant(), data); } }
static string Execute(WebClient client, string address, WebRequestMethod method, string data, bool throwError, out ErrorResultTO errors) { EnsureContentType(client); errors = new ErrorResultTO(); try { switch(method) { case WebRequestMethod.Get: return FixResponse(client.DownloadString(address)); default: return FixResponse(client.UploadString(address, method.ToString().ToUpperInvariant(), data)); } } catch(Exception e) { errors.AddError(e.Message); if(throwError) { throw; } } finally { // clean up client ;) client.Dispose(); } return string.Empty; }