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()));
            }
        }
Пример #2
0
        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
                       ));
        }
Пример #3
0
        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));
        }
Пример #4
0
        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);
        }
Пример #5
0
        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);
        }
Пример #6
0
        /// <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);
        }
Пример #7
0
 /// <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);
        }
Пример #9
0
        /// <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);
        }
Пример #10
0
        /// <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);
        }
Пример #11
0
 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
     });
 }
Пример #13
0
        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;
        }
Пример #15
0
        /// <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);
        }
Пример #16
0
 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
     });
 }
Пример #17
0
        /// <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.");
        }
Пример #18
0
 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
     });
 }
Пример #19
0
        // 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));
            }
        }
Пример #20
0
 public static Collection <PSObject> InvokeRestCommand(
     this PSCmdlet caller,
     Uri uri,
     WebRequestMethod method,
     object body,
     IDictionary headers
     )
 {
     return(caller.InvokeCommand.InvokeRestCommand(
                uri,
                method,
                body,
                headers
                ));
 }
Пример #21
0
        /// <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);
        }
Пример #22
0
        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();
            }
        }
Пример #23
0
        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);
        }
Пример #24
0
        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);
        }
Пример #25
0
        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);
            }
        }
Пример #26
0
        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);
        }
Пример #27
0
        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.");
            }
            }
        }
Пример #28
0
 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";
 }
Пример #31
0
 /// <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);
 }
Пример #32
0
 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;
        }
Пример #34
0
 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);
 }
Пример #35
0
        // 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);
            }
        }
Пример #36
0
        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;
        }