public string getResponse(string url, HttpRequestMethod method = HttpRequestMethod.GET, Dictionary<string,string> postData=null, CookieContainer cookies=null) { string result = ""; var httpWebRequest = (HttpWebRequest)WebRequest.Create(url); httpWebRequest.AllowAutoRedirect = true; httpWebRequest.AllowWriteStreamBuffering = true; httpWebRequest.KeepAlive = true; httpWebRequest.Method = method.ToString(); if(cookies!=null) httpWebRequest.CookieContainer = cookies; if (method == HttpRequestMethod.POST) { string queryString = QueryStringHelper.toQueryString(postData); byte[] b = System.Text.Encoding.ASCII.GetBytes(queryString); httpWebRequest.ContentType = "application/x-www-form-urlencoded"; httpWebRequest.ContentLength = (long)b.Length; Stream httpStream = httpWebRequest.GetRequestStream(); httpStream.Write(b, 0, b.Length); httpStream.Close(); } var objResponse = (HttpWebResponse)httpWebRequest.GetResponse(); using (var sr = new StreamReader(objResponse.GetResponseStream())) { result = sr.ReadToEnd(); sr.Close(); } return result; }
public HttpRequestWrapper(string url, HttpRequestMethod method, Encoding encode) { reqSetting = new HttpRequestSetting(url, method, encode); httpRequest = new HttpRequest(); cookieParser = new CookieParser(); }
/// <summary> /// Builds and configures an <see cref="HttpWebRequest"/> object with the given parameters. /// </summary> /// <param name="method">HTTP verb to use for the request.</param> /// <param name="uri">Address of a local or remote HTTP server.</param> /// <param name="cache">Determines whether the request should be cached.</param> /// <param name="headers">HTTP request headers to send to the server.</param> /// <returns>A fully configured <see cref="HttpWebRequest"/> object.</returns> public static HttpWebRequest BuildRequest(HttpRequestMethod method, string uri, bool cache = false, List<string> headers = null) { LogBuildRequest(method, uri, cache, headers); var request = (HttpWebRequest) WebRequest.Create(uri); request.Method = method.ToString("G").ToUpper(); request.UserAgent = UserAgent; request.KeepAlive = true; request.CachePolicy = new RequestCachePolicy(cache ? RequestCacheLevel.CacheIfAvailable : RequestCacheLevel.BypassCache); request.Expect = null; if (headers != null && headers.Count > 0) { foreach (var header in headers) { request.Headers.Add(header); } } if (HttpRequestMethod.Post == method || HttpRequestMethod.Put == method) { request.ContentType = "application/x-www-form-urlencoded"; } return request; }
public RestClient(string link, string contentType = "text/json", HttpRequestMethod method = HttpRequestMethod.GET) { Link = link; Method = method; ContentType = contentType; _parameters = new Dictionary<string, string>(); Parameters = new ReadOnlyDictionary<string, string>(_parameters); }
public static void Test_HttpRequest(string url, HttpRequestMethod method, string content, string file) { file = zPath.Combine(_directory, file); bool exportResult = HttpManager.CurrentHttpManager.ExportResult; HttpManager.CurrentHttpManager.ExportResult = true; HttpRun.LoadToFile(new HttpRequest { Url = url, Method = method, Content = content }, file, true, new HttpRequestParameters { Encoding = Encoding.UTF8 }); HttpManager.CurrentHttpManager.ExportResult = exportResult; }
/// <param name="url">${WP_mapping_ServiceBase_method_SubmitRequest_param_url_D}</param> /// <param name="parameters">${WP_mapping_ServiceBase_method_SubmitRequest_param_parameters_D}</param> /// <param name="onCompleted">${WP_mapping_ServiceBase_method_SubmitRequest_param_onCompleted_D}</param> /// <param name="state">${WP_mapping_ServiceBase_method_SubmitRequest_param_state_D}</param> /// <param name="forcePost">${WP_mapping_ServiceBase_method_SubmitRequest_param_forcePost_D}</param> /// <param name="isEditable">${WP_mapping_ServiceBase_method_SubmitRequest_param_isEditable_D}</param> /// <param name="isTempLayersSet">${WP_mapping_ServiceBase_method_SubmitRequest_param_isTempLayersSet_D}</param> /// <summary>${WP_mapping_ServiceBase_method_SubmitRequest_D}</summary> /// <overloads>${WP_mapping_ServiceBase_method_SubmitRequest_overloads_D}</overloads> protected async Task<string> SubmitRequest(string url, HttpRequestMethod method,string data) { request.Url = url; request.PostBody = data; request.ProxyUrl = ProxyURL; request.RequestMethod = method; return await request.BeginRequest(); }
private void ParseRequestMethod(string[] requestLine) { HttpRequestMethod parsedMethod; string method = requestLine[0]; string capitalizedMethod = method.Capitalize(); if (!Enum.TryParse(capitalizedMethod, true, out parsedMethod)) { throw new BadRequestException(); } this.RequestMethod = parsedMethod; }
public Response( IHeadersCollection headersCollection, int statusCode, HttpRequestMethod httpRequestMethod, byte[] responseData, TResponseBody?body, AbsoluteUrl requestUri ) : base( headersCollection, statusCode, httpRequestMethod, responseData, requestUri) => Body = body;
public bool?Contains(HttpRequestMethod requestMethod, string path) { CoreValidator.ThrowIfNull(requestMethod, nameof(requestMethod)); CoreValidator.ThrowIfNullOrEmpty(path, nameof(path)); if (!this.routes.ContainsKey(requestMethod)) { return(null); } return(this.routes[requestMethod].ContainsKey(path)); }
private void ParseRequestMethod(string[] requestLines) { HttpRequestMethod httpRequestMethod; if (!Enum.TryParse(requestLines[0], true, out httpRequestMethod)) { throw new BadRequestException( string.Format(GlobalConstants.UnsupportedHttpMethodExceptionMethod, requestLines[0])); } this.RequestMethod = httpRequestMethod; }
public ServerRouteConfig(IAppRouteConfig appRouteConfig) { this.Routes = new Dictionary <HttpRequestMethod, Dictionary <string, IRoutingContext> >(); foreach (int num in Enum.GetValues(typeof(HttpRequestMethod))) { HttpRequestMethod method = (HttpRequestMethod)num; Routes[method] = new Dictionary <string, IRoutingContext>(); } this.InitializeServerConfig(appRouteConfig); }
/// <summary> /// Instantiates a new <see cref="Route"/>. /// </summary> /// <param name="method"> The HTTP request method. </param> /// <param name="path"> The formattable relative path. </param> public Route(HttpRequestMethod method, string path) { Guard.IsDefined(method); Guard.IsNotNullOrWhiteSpace(path); if (path.StartsWith('/')) { Throw.FormatException("The path must be a relative path with no leading slash."); } Method = method; Path = path; }
private void ParseRequestMethod(string[] requestLine) { HttpRequestMethod method; bool result = HttpRequestMethod.TryParse(requestLine[0], true, out method); if (!result) { throw new BadRequestException(String.Format(GlobalConstants.UnsupportedHttpMethodExceptionMessage, requestLine[0])); } this.RequestMethod = method; }
public static void Test_HttpRequest(string url, HttpRequestMethod method, string content, string file) { file = zPath.Combine(_directory, file); bool exportResult = HttpManager.CurrentHttpManager.ExportResult; HttpManager.CurrentHttpManager.ExportResult = true; HttpRun_v1.LoadToFile(new HttpRequest { Url = url, Method = method, Content = content }, file, true, new HttpRequestParameters { Encoding = Encoding.UTF8 }); HttpManager.CurrentHttpManager.ExportResult = exportResult; }
protected HttpResponse Execute(HttpRequestMethod method, string relativePath, Action <HttpWebRequest> modifyRequest = null, Action <Stream> writeToUpStream = null, Action <HttpWebResponse> handleResponse = null, Action <Stream> readDownStream = null) { var output = new HttpResponse(); try { var httpRequest = CreateRequest(method, relativePath); using (_cancelToken?.Register(() => { httpRequest.Abort(); })) { modifyRequest?.Invoke(httpRequest); // write to upstream if (writeToUpStream != null) { using (var upStream = httpRequest.GetRequestStream()) { writeToUpStream(upStream); } } // get response using (var httpWebResponse = (HttpWebResponse)httpRequest.GetResponse()) { output.StatusCode = httpWebResponse.StatusCode; output.StatusDescription = httpWebResponse.StatusDescription; handleResponse?.Invoke(httpWebResponse); // read downstream if (readDownStream != null) { using (var downStream = httpWebResponse.GetResponseStream()) { readDownStream(downStream); } } } } } catch (Exception e) { output.Exception = e; if (e is WebException we && we.Response is HttpWebResponse hwr) { output.StatusCode = hwr.StatusCode; output.StatusDescription = hwr.StatusDescription; } } if (!(output.Exception is OperationCanceledException) && (_cancelToken?.IsCancellationRequested ?? false)) { output.Exception = new OperationCanceledException(); } return(output); }
private void ParseRequestMethod(string[] requestLineParams) { string methodName = requestLineParams[0]; HttpRequestMethod requestMethod; bool isParsed = Enum.TryParse(methodName, true, out requestMethod); if (!isParsed) { throw new BadRequestException(); } this.RequestMethod = requestMethod; }
public static HttpMethod GetHttpMethod(HttpRequestMethod method) { switch (method) { case HttpRequestMethod.Get: return(HttpMethod.Get); case HttpRequestMethod.Post: return(HttpMethod.Post); default: throw new PBException($"unknow HttpRequestMethod {method}"); } }
private void ParseRequestMethod(string[] requestLine) { if (!requestLine.Any()) { throw new BadRequestException(); } var parseResult = System.Enum.TryParse <HttpRequestMethod>(requestLine[0], out var parsedRequestmethod); if (!parseResult) { throw new BadRequestException(); } this.RequestMethod = parsedRequestmethod; }
private void ParseRequestMethod(string[] requestLineParams) { string requestMethod = requestLineParams[0]; HttpRequestMethod method; bool parseResult = HttpRequestMethod.TryParse(requestMethod, true, out method); if (!parseResult) { throw new BadRequestException(string.Format(GlobalConstants.UnsupportedHttpMethodExceptionMessage, requestMethod)); } this.RequestMethod = method; }
public IHttpResponse Handle(IHttpContext httpContext) { try { string loginPath = "/login"; string registerPath = "/register"; //if (httpContext.Request.Path != loginPath // && httpContext.Request.Path != registerPath // && !httpContext.Request.Session.Containts(CurrentUserSessionKey)) //{ // return new RedirectResponse(loginPath); //} HttpRequestMethod requestMethod = httpContext.Request.RequestMethod; string requestPath = httpContext.Request.Path; var registeredRoutes = this.serverRouteConfig.Routes[requestMethod]; foreach (var registeredRoute in registeredRoutes) { string routePattern = registeredRoute.Key; IRoutingContext routingContext = registeredRoute.Value; Regex regex = new Regex(routePattern); Match match = regex.Match(requestPath); if (!match.Success) { continue; } var parameters = routingContext.Parameters; foreach (string parameter in parameters) { string parameterValue = match.Groups[parameter].Value; httpContext.Request.AddUrlParameter(parameter, parameterValue); } return(routingContext.RequestHandler.Handle(httpContext)); } } catch (Exception ex) { return(new InternalServerErrorResponse(ex)); } return(new NotFoundResponse()); }
public IHttpResponse Handle(IHttpContext context) { try { // Check if user is authenticated string[] anonymousPaths = new[] { "/login", "/register" }; if (!anonymousPaths.Contains(context.HttpRequest.Path) && (context.HttpRequest.Session == null || !context.HttpRequest.Session.Contains(SessionRepository.CurrentUserKey))) { return(new RedirectResponse(anonymousPaths.First())); } HttpRequestMethod requestMethod = context.HttpRequest.RequestMethod; string requestPath = context.HttpRequest.Path; IDictionary <string, IRoutingContext> registeredRoutes = this.serverRouteConfig.Routes[requestMethod]; foreach (KeyValuePair <string, IRoutingContext> registeredRoute in registeredRoutes) { string routePattern = registeredRoute.Key; IRoutingContext routeContext = registeredRoute.Value; Regex routeRegex = new Regex(routePattern); Match match = routeRegex.Match(requestPath); if (!match.Success) { continue; } IEnumerable <string> parameters = routeContext.Parameters; foreach (string parameter in parameters) { string parameterValue = match.Groups[parameter].Value; context.HttpRequest.AddUrlParameter(parameter, parameterValue); } return(routeContext.RequestHandler.Handle(context)); } } catch (Exception exception) { return(new InternalServerErrorResponse(exception)); } return(new NotFoundResponse()); }
private string HttpMethodToString(HttpRequestMethod httpMethod) { switch (httpMethod) { case HttpRequestMethod.HttpMethod_Post: return("POST"); case HttpRequestMethod.HttpMethod_Get: return("GET"); default: return("POST"); } }
private void ResolveRelationDependency( object model, string requesterID, IRequest request, IRequest relatedRequest, TRelation intractionType, HttpRequestMethod httpRequestMethod) { var propertyList = model.GetType() .GetProperties() .Where(property => property.IsDefined(typeof(RelationDependentValueAttribute), true)) .ToList(); var updateModel = false; foreach (var item in propertyList) { var attribute = item.GetCustomAttribute <RelationDependentValueAttribute> (); var relationDependentResolver = httpRequestMethod == HttpRequestMethod.Post ? attribute.OnRelationCreated : attribute.OnReleationDeleted; var result = APIUtils.InvokeMethod( relationDependentResolver, "OnRelationEvent", new object[] { dbContext, model, requesterID, request, relatedRequest, intractionType, httpRequestMethod }); if (result != null) { model = result; updateModel = true; } } if (updateModel) { dbContext.Update(model); } }
public dynamic ModelValidation( IRequest Request, Type ModelType, ModelAction ModelAction, HttpRequestMethod RequestMethod, TRelation RelationType) => GeneralAccessChainValidation( Request: Request, Type: ModelType, ModelAction: ModelAction, RequestMethod: RequestMethod, RelationType: RelationType, ModelItself: null, TypeValue: Request.IdentifierValue, DefaultPolicy: false);
public dynamic ModelPropertyValidation( IRequest Request, PropertyInfo PropertyInfo, object Model, ModelAction ModelAction, HttpRequestMethod RequestMethod) => GeneralAccessChainValidation( Request: Request, Type: PropertyInfo, ModelAction: ModelAction, RequestMethod: RequestMethod, RelationType: default(TRelation), TypeValue: PropertyInfo.GetValue(Model), ModelItself: Model, DefaultPolicy: true);
/// <summary> /// Instantiates a new <see cref="Route"/>. /// </summary> /// <param name="method"> The HTTP request method. </param> /// <param name="path"> The formattable relative path. </param> public Route(HttpRequestMethod method, string path) { if (string.IsNullOrWhiteSpace(path)) { throw new ArgumentNullException(nameof(path)); } if (path.StartsWith('/')) { throw new FormatException("The path must be a relative path with no leading slash."); } Method = method; Path = path; }
public static string GetMethodString(this HttpRequestMethod method) { switch (method) { case HttpRequestMethod.Get: return("get"); case HttpRequestMethod.Post: return("post"); case HttpRequestMethod.Put: return("put"); case HttpRequestMethod.Delete: return("delete"); default: return(method.ToString()); } }
/// <summary> /// Initializes a new instance of the <see cref="HttpSensorParameters"/> class. /// </summary> /// <param name="url">The URL to monitor.</param> /// <param name="sensorName">The name to use for this sensor.</param> /// <param name="requestMethod">The HTTP request method to use.</param> /// <param name="timeout">The duration (in seconds) this sensor can run for before timing out. This value must be between 1-900.</param> /// <param name="postData">Data to include in requests when the HTTP request method is <see cref="PrtgAPI.HttpRequestMethod.POST"/>.</param> /// <param name="useCustomPostContent">Whether to use a custom content type in POST requests.</param> /// <param name="postContentType">The custom content type to use in POST requests.</param> /// <param name="useSNIFromUrl">Whether the Server Name Indication should be derived from the specified <see cref="Url"/>, or from the parent device.</param> public HttpSensorParameters(string url = "http://", string sensorName = "HTTP", HttpRequestMethod requestMethod = HttpRequestMethod.GET, int timeout = 60, string postData = null, bool useCustomPostContent = false, string postContentType = null, bool useSNIFromUrl = false) : base(sensorName, SensorType.Http) { Url = url; HttpRequestMethod = requestMethod; Timeout = timeout; PostData = postData; UseCustomPostContent = useCustomPostContent; PostContentType = postContentType; UseSNIFromUrl = useSNIFromUrl; //todo: add a unit test for this to our existing test files that test on wmi service/exexml sensors //update about_sensorsettings to document the new objectproperty types //make a note to update wiki to say this type is now nataively supported }
private static void AutoRegisterRoutes(IMvcApplication application, IServerRoutingTable serverRoutingTable, IServiceProvider serviceProvider, RouteSettings routeSettings) { IEnumerable <System.Type> controllers = application.GetType().Assembly .GetTypes() .Where(type => type.IsClass && !type.IsAbstract && typeof(Controller).IsAssignableFrom(type)); foreach (var controllerType in controllers) { IEnumerable <MethodInfo> actions = controllerType.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public) .Where(m => !m.IsSpecialName && !m.IsVirtual && m.GetCustomAttribute <NonActionAttribute>() == null); string controllerName = controllerType.Name.Replace("Controller", ""); AuthorizeAttribute controllerAuthorizeAttribute = controllerType.GetCustomAttribute <AuthorizeAttribute>() as AuthorizeAttribute; foreach (var action in actions) { string path = $"/{controllerName}/{action.Name}"; BaseHttpAttribute attribute = action.GetCustomAttributes() .LastOrDefault(a => a.GetType().IsSubclassOf(typeof(BaseHttpAttribute))) as BaseHttpAttribute; HttpRequestMethod requestMethod = HttpRequestMethod.Get; if (attribute != null) { requestMethod = attribute.HttpRequestMethod; } if (attribute?.ActionName != null) { path = $"/{controllerName}/{attribute.ActionName}"; } if (attribute?.Url != null) { path = attribute.Url; } serverRoutingTable.Add(requestMethod, path, request => { return(ProcessRequest(serviceProvider, request, controllerType, controllerAuthorizeAttribute, action, routeSettings)); }); } } }
protected Response( IHeadersCollection headersCollection, int statusCode, HttpRequestMethod httpRequestMethod, byte[] responseData, TResponseBody body, Uri requestUri ) : base( headersCollection, statusCode, httpRequestMethod, responseData, requestUri) { Body = body; }
public static HttpMethod GetMethod(this HttpRequestMethod requestMethod) { switch (requestMethod) { case HttpRequestMethod.Get: return(HttpMethod.Get); case HttpRequestMethod.Post: return(HttpMethod.Post); case HttpRequestMethod.Put: return(HttpMethod.Put); case HttpRequestMethod.Delete: return(HttpMethod.Delete); default: throw new ArgumentOutOfRangeException(nameof(requestMethod)); } }
private void ParseRequestMethod(string[] requestLine) { if (!requestLine.Any()) { throw new BadRequestException(); } bool parsed = Enum.TryParse(requestLine[0].Capitalize(), out HttpRequestMethod requestMethod); if (!parsed) { throw new BadRequestException(); } this.RequestMethod = requestMethod; }
private dynamic CreateResource( IRequest request, HttpRequestMethod requestMethod, PermissionHandler <TRelation, TUser> permissionHandler, string jsonData) { var jsonResolver = new APIJsonResolver <TRelation, TUser> { DbContext = dbContext, PermissionHandler = permissionHandler, ModelAction = ModelAction.Create, RequestMethod = requestMethod, IRequest = request, IncludeKey = false, IncludeBindNever = false, EngineService = EngineService }; var serializerSettings = JsonConvert.DefaultSettings(); serializerSettings.ContractResolver = jsonResolver; var model = JsonConvert.DeserializeObject( value: jsonData, type: request.Temp_ResourceType, settings: serializerSettings); dbContext.Add(model); dbContext.SaveChanges(); var intraction = new ModelInteraction <TRelation> { CreatorId = permissionHandler.getRequesterID(), FirstModelId = permissionHandler.getRequesterID(), SecondModelId = model.GetKeyPropertyValue(), IntractionType = (TRelation)Enum.Parse(typeof(TRelation), "Global"), ModelAction = ModelAction.Create }; dbContext.MagicAddIntraction(intraction, EngineService.MapRelationToType("Global")); dbContext.SaveChangesAsync(); EngineService.OnResourceCreated(dbContext, request, model, intraction); return(new OkObjectResult(new { GeneratedID = model.GetKeyPropertyValue() })); }
internal static string HttpPost(string url, List<string> parameters, CredentialBase credential, HttpRequestMethod httpRequestMethod) { url += ".json?"; parameters = parameters.Where(p => !string.IsNullOrEmpty(p)).ToList(); url = GenerateUrl(url, parameters); HttpWebRequest httpRequest; if (credential.GetType() == typeof(Credential.OAuth)) { if (!((Credential.OAuth)credential).HasToken) ((Credential.OAuth)credential).Login(); httpRequest = HttpPostOAuth(url, (Credential.OAuth)credential, httpRequestMethod); } else httpRequest = HttpPostBasic(url, credential, httpRequestMethod); try { using (var response = (HttpWebResponse)httpRequest.GetResponse()) using (var reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8)) { var result = reader.ReadToEnd(); return result; } } catch (WebException ex) { var result = new StreamReader(ex.Response.GetResponseStream(), Encoding.UTF8).ReadToEnd(); var error = new JavaScriptSerializer().Deserialize<ErrorObj>(result); if (!string.IsNullOrEmpty(error.Error)) throw new Exception.WebException(error.Error); if (!string.IsNullOrEmpty(error.RateLimited)) throw new Exception.RateLimitedException(error.RateLimited); if (!string.IsNullOrEmpty(error.Unauthorized)) throw new Exception.UnauthorizedException(error.Unauthorized); throw; } }
/// <summary> /// Sends a HTTP Request with the chosen request method /// </summary> /// <param name="url">Url to send request to</param> /// <param name="method">HTTP Request Method to use</param> /// <param name="data">Query string data to send</param> /// <param name="count">How many times to try the connection before giving up</param> public static string SendRequest(string url, HttpRequestMethod method, Dictionary<string, string> data = null, int count = 3) { // Try sending n times for(int i = 0; i < count; i++) { switch(method) { case HttpRequestMethod.POST: return SendPost(url, GetRequestString(data)); case HttpRequestMethod.GET: return SendGet(url + "?" + GetRequestString(data)); case HttpRequestMethod.PUT: return SendPut(url, GetRequestString(data)); case HttpRequestMethod.DELETE: return SendDelete(url); } } throw new Exception("Request failed to send. Unknown error. Please check the parameters for errors."); }
public SerializeValueProvider( IValueProvider ValueProvider, PermissionHandler <TRelation, TUser> PermissionHandler, IRequest IRequest, TRelation Relation, PropertyInfo PropertyType, ModelAction modelAction, HttpRequestMethod requestMethod) { this.ValueProvider = ValueProvider; this.PermissionHandler = PermissionHandler; this.IRequest = IRequest; this.PropertyType = PropertyType; this.ModelAction = modelAction; this.RequestMethod = requestMethod; this.Relation = Relation; }
private void ParseRequestMethod(string[] requestLine) { if (!requestLine.Any()) { throw new BadRequestException(); } string reqMethod = requestLine[0]; bool tryParseReqMethod = Enum.TryParse(reqMethod, true, out HttpRequestMethod method); if (!tryParseReqMethod) { throw new BadRequestException(); } this.RequestMethod = method; }
public void RequestAsync(HttpRequestMethod method, byte[] data, OnRESTResponse onRequest, params string[] headers) { Worker.WorkerDelegate onWork = delegate(out object result) { Request(method, data, null, headers); result = null; return(true); }; Worker.WorkerFinishedDelegate onFinish = delegate(Exception e, object result) { //if (e != null) // throw e; //onRequest?.Invoke(m_error == null, m_error == null ? null : m_error.ToString(), m_stream); onRequest?.Invoke(m_error == null, m_error == null ? null : m_error.ToString(), m_stream); }; Worker.StartWorker(onWork, onFinish); }
/// <summary> /// Get an instance of a request class /// </summary> /// <returns> /// The instance /// </returns> /// <param name="method"> /// The method that the request class should implement /// </param> /// <exception cref="NotSupportedException"> /// Thrown if the given method has yet to be supported. /// </exception> public static EasyHttpRequest GetInstance(HttpRequestMethod method) { switch (method) { case HttpRequestMethod.Post: { return new PostEasyHttpRequest(); } case HttpRequestMethod.Get: { return new GetEasyHttpRequest(); } default: { throw new NotSupportedException(String.Format("The HttpRequestMethod '{0}' is not supported yet", method)); } } }
public static HttpStatusCode PerformRequest(HttpRequestMethod method, string urlPath) { return PerformRequest(method, urlPath, null, null, null); }
protected virtual HttpStatusCode PerformRequest(HttpRequestMethod method, string urlPath, WriteXmlDelegate writeXmlDelegate, ReadXmlDelegate readXmlDelegate, ReadXmlListDelegate readXmlListDelegate) { var url = Settings.GetServerUri(urlPath); #if (DEBUG) Console.WriteLine("Requesting " + method + " " + url); #endif var request = (HttpWebRequest)WebRequest.Create(url); request.Accept = "application/xml"; // Tells the server to return XML instead of HTML request.ContentType = "application/xml; charset=utf-8"; // The request is an XML document request.SendChunked = false; // Send it all as one request request.UserAgent = Settings.UserAgent; request.Headers.Add(HttpRequestHeader.Authorization, Settings.AuthorizationHeaderValue); request.Method = method.ToString().ToUpper(); Debug.WriteLine(String.Format("Recurly: Requesting {0} {1}", request.Method, request.RequestUri)); if ((method == HttpRequestMethod.Post || method == HttpRequestMethod.Put) && (writeXmlDelegate != null)) { // 60 second timeout -- some payment gateways (e.g. PayPal) can take a while to respond request.Timeout = 60000; // Write POST/PUT body using (var requestStream = request.GetRequestStream()) { WritePostParameters(requestStream, writeXmlDelegate); } } else { request.ContentLength = 0; } try { using (var response = (HttpWebResponse)request.GetResponse()) { ReadWebResponse(response, readXmlDelegate, readXmlListDelegate); return response.StatusCode; } } catch (WebException ex) { if (ex.Response == null) throw; var response = (HttpWebResponse)ex.Response; var statusCode = response.StatusCode; Error[] errors; Debug.WriteLine(String.Format("Recurly Library Received: {0} - {1}", (int)statusCode, statusCode)); switch (response.StatusCode) { case HttpStatusCode.OK: case HttpStatusCode.Accepted: case HttpStatusCode.Created: case HttpStatusCode.NoContent: ReadWebResponse(response, readXmlDelegate, readXmlListDelegate); return HttpStatusCode.NoContent; case HttpStatusCode.NotFound: errors = Error.ReadResponseAndParseErrors(response); if (errors.Length > 0) throw new NotFoundException(errors[0].Message, errors); throw new NotFoundException("The requested object was not found.", errors); case HttpStatusCode.Unauthorized: case HttpStatusCode.Forbidden: errors = Error.ReadResponseAndParseErrors(response); throw new InvalidCredentialsException(errors); case HttpStatusCode.PreconditionFailed: errors = Error.ReadResponseAndParseErrors(response); throw new ValidationException(errors); case HttpStatusCode.ServiceUnavailable: throw new TemporarilyUnavailableException(); case HttpStatusCode.InternalServerError: errors = Error.ReadResponseAndParseErrors(response); throw new ServerException(errors); } if ((int)statusCode == ValidationException.HttpStatusCode) // Unprocessable Entity { errors = Error.ReadResponseAndParseErrors(response); if (errors.Length > 0) Debug.WriteLine(errors[0].ToString()); else Debug.WriteLine("Client Error: " + response.ToString()); throw new ValidationException(errors); } throw; } }
public HttpStatusCode PerformRequest(HttpRequestMethod method, string urlPath, ReadXmlListDelegate readXmlListDelegate) { return PerformRequest(method, urlPath, null, null, readXmlListDelegate); }
public HttpStatusCode PerformRequest(HttpRequestMethod method, string urlPath, WriteXmlDelegate writeXmlDelegate, ReadXmlDelegate readXmlDelegate) { return PerformRequest(method, urlPath, writeXmlDelegate, readXmlDelegate, null); }
public static string SendRequest(string url, HttpRequestMethod method, int count = 3) { Exception ex = null; for(int i = 0; i < count; i++) //Try sending 3 Times { var request = GetJsonRequest(url, method); try { var response = (HttpWebResponse)request.GetResponse(); if(response.StatusCode == HttpStatusCode.OK || response.StatusCode == HttpStatusCode.Created) { using(var stream = new StreamReader(response.GetResponseStream())) return stream.ReadToEnd(); } else if(response.StatusCode == HttpStatusCode.InternalServerError) count--; } catch(Exception e) { ex = e; } } throw ex; }
public static HttpStatusCode PerformRequest(HttpRequestMethod method, string urlPath, Action<XmlTextWriter> writeXmlDelegate, Action<XmlTextReader> readXmlDelegate, Action<WebHeaderCollection> headersDelegate) { var url = urlPath.Contains("http") ? urlPath : ServerUrl + urlPath; var request = (HttpWebRequest)WebRequest.Create(url); request.Accept = "application/xml"; // Tells the server to return XML instead of HTML request.SendChunked = false; // Send it all as one request request.UserAgent = UserAgent; request.Headers.Add(HttpRequestHeader.Authorization, AuthorizationHeaderValue); request.Method = method.ToString().ToUpper(); System.Diagnostics.Debug.WriteLine("Recurly: Requesting {0} {1}", request.Method, request.RequestUri); if (method == HttpRequestMethod.Post || method == HttpRequestMethod.Put) { request.ContentLength = 0; // 60 second timeout -- some payment gateways (e.g. PayPal) can take a while to respond request.Timeout = 60000; if(writeXmlDelegate != null) { request.ContentType = "application/xml; charset=utf-8"; // The request is an XML document // Write POST/PUT body using (var ms = new MemoryStream()) { WritePostParameters(ms, writeXmlDelegate); var bytes = ms.ToArray(); System.Diagnostics.Debug.WriteLine("Recurly Body: {0}{1}",Environment.NewLine,Encoding.UTF8.GetString(bytes)); request.ContentLength = bytes.Length; request.GetRequestStream().Write(bytes, 0, bytes.Length); } } } try { using (var response = (HttpWebResponse)request.GetResponse()) return ReadWebResponse(response, readXmlDelegate, headersDelegate); } catch (WebException ex) { if (ex.Response != null) { var response = (HttpWebResponse)ex.Response; var statusCode = response.StatusCode; List<RecurlyError> errors; System.Diagnostics.Debug.WriteLine("Recurly Library Received: {0} - {1}", (int) statusCode, statusCode); switch (response.StatusCode) { case HttpStatusCode.OK: case HttpStatusCode.Accepted: case HttpStatusCode.Created: case HttpStatusCode.NoContent: return ReadWebResponse(response, readXmlDelegate, headersDelegate); case HttpStatusCode.NotFound: //return response.StatusCode; errors = RecurlyError.ReadResponseAndParseErrors(response); if (errors.Any()) throw new NotFoundException(errors[0].Symbol, errors); throw new NotFoundException("The requested object was not found.", errors); case HttpStatusCode.Unauthorized: case HttpStatusCode.Forbidden: errors = RecurlyError.ReadResponseAndParseErrors(response); throw new InvalidCredentialsException(errors); case HttpStatusCode.PreconditionFailed: errors = RecurlyError.ReadResponseAndParseErrors(response); throw new ValidationException(errors); case HttpStatusCode.ServiceUnavailable: throw new TemporarilyUnavailableException(); case HttpStatusCode.InternalServerError: errors = RecurlyError.ReadResponseAndParseErrors(response); throw new RecurlyServerException(errors); } if ((int)statusCode == ValidationException.HttpStatusCode) // Unprocessable Entity { errors = RecurlyError.ReadResponseAndParseErrors(response); throw new ValidationException(errors); } } throw; } }
public static HttpStatusCode PerformRequest(HttpRequestMethod method, string urlPath, WriteXmlDelegate writeXmlDelegate, ReadXmlDelegate readXmlDelegate) { HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(ServerUrl(Environment) + urlPath); request.Accept = "application/xml"; // Tells the server to return XML instead of HTML request.ContentType = "application/xml"; // The request is an XML document request.SendChunked = false; // Send it all as one request request.UserAgent = UserAgent; request.Headers.Add(HttpRequestHeader.Authorization, AuthorizationHeaderValue); request.Method = method.ToString().ToUpper(); System.Diagnostics.Debug.WriteLine(String.Format("Recurly: Requesting {0} {1}", request.Method, request.RequestUri.ToString())); if ((method == HttpRequestMethod.Post || method == HttpRequestMethod.Put) && (writeXmlDelegate != null)) { // 60 second timeout -- some payment gateways (e.g. PayPal) can take a while to respond request.Timeout = 60000; // Write POST/PUT body using (Stream requestStream = request.GetRequestStream()) WritePostParameters(requestStream, writeXmlDelegate); } try { HttpWebResponse response = (HttpWebResponse)request.GetResponse(); return ReadWebResponse(response, readXmlDelegate); } catch (WebException ex) { if (ex.Response != null) { HttpWebResponse response = (HttpWebResponse)ex.Response; HttpStatusCode statusCode = response.StatusCode; RecurlyError[] errors; System.Diagnostics.Debug.WriteLine(String.Format("Recurly Library Received: {0} - {1}", (int)statusCode, statusCode.ToString())); switch (response.StatusCode) { case HttpStatusCode.OK: case HttpStatusCode.Accepted: case HttpStatusCode.Created: case HttpStatusCode.NoContent: return ReadWebResponse(response, readXmlDelegate); case HttpStatusCode.NotFound: errors = RecurlyError.ReadResponseAndParseErrors(response); if (errors.Length >= 0) throw new NotFoundException(errors[0].Message, errors); else throw new NotFoundException("The requested object was not found.", errors); case HttpStatusCode.Unauthorized: case HttpStatusCode.Forbidden: errors = RecurlyError.ReadResponseAndParseErrors(response); throw new InvalidCredentialsException(errors); case HttpStatusCode.PreconditionFailed: errors = RecurlyError.ReadResponseAndParseErrors(response); throw new ValidationException(errors); case HttpStatusCode.ServiceUnavailable: throw new TemporarilyUnavailableException(); case HttpStatusCode.InternalServerError: errors = RecurlyError.ReadResponseAndParseErrors(response); throw new RecurlyServerException(errors); } if ((int)statusCode == ValidationException.HttpStatusCode) // Unprocessable Entity { errors = RecurlyError.ReadResponseAndParseErrors(response); throw new ValidationException(errors); } } throw; } }
/// <summary> /// 根据给定地址和请求类型获取内容 /// </summary> /// <param name="url">请求地址(可直接带参数)</param> /// <param name="method">请求方法</param> /// <param name="type">请求内容类型</param> /// <param name="content">请求内容(不需要就不传)</param> /// <returns></returns> public static string GetHttpResponse(string url, HttpRequestMethod method = HttpRequestMethod.GET, HttpRequestContentType type = HttpRequestContentType.Default, string content = null) { // 创建 WebRequest 对象,WebRequest 是抽象类,定义了规范 // HttpWebRequest 是 WebRequest 的派生类,专门用于 HTTP 请求 var request = (HttpWebRequest)HttpWebRequest.Create(url); // 请求的方式通过 Method 属性设置 ,默认为 GET // 可以将 Method 属性设置为任何 HTTP 1.1 协议谓词:GET、HEAD、POST、PUT、DELETE、TRACE 或 OPTIONS。 switch (method) { case HttpRequestMethod.POST: request.Method = "POST"; break; case HttpRequestMethod.GET: default: request.Method = "GET"; break; } // 设置请求的内容类型 switch (type) { case HttpRequestContentType.UrlEncoded: request.ContentType = "application/x-www-form-urlencoded"; content = HttpContext.Current.Server.UrlEncode(content); break; case HttpRequestContentType.Json: request.ContentType = "application/json"; break; case HttpRequestContentType.Default: default: //request.ContentType = "text/plain"; break; } // 如果有请求内容的话,写入请求流中 if (!string.IsNullOrWhiteSpace(content)) { // 取得发向服务器的流 using (var requestStream = request.GetRequestStream()) { // 使用 POST 方法请求的时候,实际的参数通过请求的 Body 部分以流的形式传送 using (var writer = new StreamWriter(requestStream)) { writer.Write(content); } // 设置请求参数的长度. request.ContentLength = requestStream.Length; } } #region Cookies暂不需要 // 还可以在请求中附带 Cookie // 但是,必须首先创建 Cookie 容器 //request.CookieContainer = new CookieContainer(); //var requestCookie = new System.Net.Cookie("Request", "RequestValue", "/", "localhost"); //request.CookieContainer.Add(requestCookie); #endregion HttpWebResponse response; try { // GetResponse 方法才真的发送请求,等待服务器返回 response = (HttpWebResponse)request.GetResponse(); } catch (WebException ex) { response = ex.Response as HttpWebResponse; SignalRHelper.SendMessageToChatRoom("HTTP请求异常", response == null ? ex.Message : response.StatusDescription); } // 对请求结果的处理 if (response != null) { // 请求成功得到以流的形式表示的回应内容 using (var responseStream = response.GetResponseStream()) { if (responseStream != null) { string result; //读取返回内容 using (var reader = new StreamReader(responseStream)) { result = reader.ReadToEnd(); } return result; } } } return string.Empty; }
public bool LoadToFile(string path, string url, HttpRequestMethod method, string content) { return LoadToFile(path, url, method, content, null); }
private static void LogBuildRequest(HttpRequestMethod method, string uri, bool cache = false, List<string> headers = null) { var strHeaders = ""; if (headers != null && headers.Count > 0) { strHeaders = string.Format(" with headers: {0}", string.Join("; ", headers)); } Logger.DebugFormat("{0} \"{1}\" -- cache = {2}{3}", method.ToString("G").ToUpper(), uri, cache, strHeaders); }
public void ResetParameters() { if (gbResult) { gMethod = HttpRequestMethod.Get; //gsAccept = null; gsReferer = null; //gAutomaticDecompression = null; gHeaders = new NameValueCollection(); gsRequestContentType = null; gsContent = null; //gEncoding = null; //gbUseWebClient = false; //giLoadXmlRetryTimeout = 0; //gsTraceDirectory = null; gsTextExportPath = null; //gbReadCommentInText = false; gsTextResult = null; gsContentType = null; gsCharset = null; gbResult = false; } }
public static HttpStatusCode PerformRequest(HttpRequestMethod method, string urlPath, Action<XmlTextReader> readXmlDelegate, Action<WebHeaderCollection> headersDelegate) { return PerformRequest(method, urlPath, null, readXmlDelegate, headersDelegate); }
public static void DownLoad(string path, string url, HttpRequestMethod method, string content, string referer) { Http http = new Http(); http.LoadToFile(path, url, method, content, referer); }
public static HttpStatusCode PerformRequest(HttpRequestMethod method, string urlPath, Action<XmlTextWriter> writeXmlDelegate, Action<XmlTextReader> readXmlDelegate) { return PerformRequest(method, urlPath, writeXmlDelegate, readXmlDelegate, null); }
public static string LoadText(string url, HttpRequestMethod method, string content) { return LoadText(url, method, content, null); }
public static string LoadText(string url, HttpRequestMethod method, string content, string referer) { Http http = new Http(); http.Load(url, method, content, referer); return http.TextResult; }
public void Load(string url, HttpRequestMethod method, string content, string referer) { Reset(); gsUrl = GetUrl(gsUrl, url); gMethod = method; gsContent = content; gsReferer = referer; Load(); }
public static void DownLoad(string path, string url, HttpRequestMethod method, string content) { DownLoad(path, url, method, content, null); }
static WebRequest GetJsonRequest(string url, HttpRequestMethod method) { var request = WebRequest.Create(url); request.Method = Enum.GetName(typeof(HttpRequestMethod), method).ToUpper(); request.ContentType = "application/json"; request.ContentLength = 0; return request; }
public bool LoadToFile(string path, string url, HttpRequestMethod method, string content, string referer) { Reset(); gsUrl = GetUrl(gsUrl, url); gMethod = method; gsContent = content; gsReferer = referer; return LoadToFile(path); }
private static string PutOrPost(HttpRequestMethod method, string uri, IDictionary<string, string> formData) { var request = BuildRequest(method, uri); using (var requestStream = request.GetRequestStream()) { using (var streamWriter = new StreamWriter(requestStream)) { var body = new List<string>(); if (formData != null) { body.AddRange(formData.Keys.Select(key => EncodeForPostBody(key, formData[key]))); } streamWriter.Write(string.Join("&", body) + "\n"); streamWriter.Flush(); streamWriter.Close(); } } NotifyBeforeRequest(request); using (var httpResponse = request.GetResponse()) { using (var responseStream = httpResponse.GetResponseStream()) { if (responseStream == null) { return null; } using (var streamReader = new StreamReader(responseStream)) { var responseText = streamReader.ReadToEnd(); return responseText; } } } }