///<summary>Checks whether a specified string is a valid HTTP query string.</summary>
///<param name="Query">The query to check.</param>
///<returns>True if the specified string is a valid HTTP query, false otherwise.</returns>
private bool IsValidQuery(string Query)
{
int index = Query.IndexOf("\r\n\r\n");
if (index == -1)
{
return(false);
}
HeaderFields = ParseQuery(Query);
if (HttpRequestType.ToUpper().Equals("POST"))
{
try
{
int length = int.Parse((string)HeaderFields["Content-Length"]);
return(Query.Length >= index + 6 + length);
}
catch
{
SendBadRequest();
return(true);
}
}
else
{
return(true);
}
}
public HttpCommand(uint id, HttpRequestType type, string url, string body)
{
Id = id;
Type = type;
Url = url;
Body = body;
}
public static async Task <JObject> ProcessRequests(String url, HttpRequestType requestType, JsonContent Data = null)
{
JObject json = null;
var client = ClientHelper.GetClient();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
switch (requestType)
{
case HttpRequestType.POST:
{
var stringTask = client.PostAsync(url, Data);
var response = await stringTask;
if (response.IsSuccessStatusCode)
{
Console.WriteLine("\nProcess succeed");
}
else
{
Console.WriteLine("Something went wrong :(\n" + response.ToString());
}
break;
}
case HttpRequestType.GET:
{
var stringTask = client.GetStringAsync(url);
var response = await stringTask;
json = JObject.Parse(response.ToString());
break;
}
}
return(json);
}
public override Task <HttpResponseMessage> ExecuteAsync(HttpRequestType requestType, Uri uri = null, string relativeUri = null, string content = null, int waitMillis = 0, bool bAddAuthorizationHeader = true)
{
// Ensure we have exactly one usable Uri
if (string.IsNullOrEmpty(relativeUri) && uri == null)
{
throw new OktaException("Cannot execute an Http request without a Uri");
}
if (!string.IsNullOrEmpty(relativeUri) && uri != null)
{
throw new OktaException("Http request is ambiguous: cannot determine whether to execute " + uri + " or " + relativeUri);
}
try
{
// Wait
Utils.Sleep(waitMillis);
// Handle GETs
if (requestType == HttpRequestType.GET)
{
return(uri != null?this.httpClient.GetAsync(uri) : this.httpClient.GetAsync(relativeUri));
}
// Handle POSTs
if (requestType == HttpRequestType.POST)
{
content = content ?? string.Empty;
if (!bAddAuthorizationHeader)
{
httpClient.DefaultRequestHeaders.Remove("Authorization");
}
return(uri != null?this.httpClient.PostAsync(uri, new StringContent(content, Encoding.UTF8, "application/json"))
: this.httpClient.PostAsync(relativeUri, new StringContent(content, Encoding.UTF8, "application/json")));
}
// Handle PUTs
if (requestType == HttpRequestType.PUT)
{
content = content ?? string.Empty;
return(uri != null?this.httpClient.PutAsync(uri, new StringContent(content, Encoding.UTF8, "application/json")) : this.httpClient.PutAsync(relativeUri, new StringContent(content, Encoding.UTF8, "application/json")));
}
// Handle DELETEs
if (requestType == HttpRequestType.DELETE)
{
return(uri != null?this.httpClient.DeleteAsync(uri) : this.httpClient.DeleteAsync(relativeUri));
}
throw new OktaException("The " + requestType + " http verb is not yet supported");
}
catch (OktaException)
{
throw;
}
catch (Exception e)
{
throw new OktaException("Error making an HTTP request: " + e.Message, e);
}
}
public NotificationRequester(int noticeName, string keyInUrlMrg, HttpRequestType requestType = HttpRequestType.Post) : base(keyInUrlMrg, requestType)
{
noticeName.Add(OnResponserInit);
NotificationResponseIniter initer = ResponserIniter as NotificationResponseIniter;
initer.Init(noticeName, true);
}
public HttpRequest(RawRequest request)
: base(request)
{
type = HttpRequestType.HttpPage;
Requests = new Dictionary<string, string>();
UrlParameters = new Dictionary<string, string>();
}
//private readonly JavaScriptSerializer serializer = new JavaScriptSerializer();
/// <summary>
/// Calls a http webservice, only supports GET and POST as of now
/// </summary>
/// <typeparam name="T">Type of response</typeparam>
/// <param name="url">Url of service</param>
/// <param name="httpRequestType">GET or POST</param>
/// <param name="requestObj">The request object</param>
/// <returns></returns>
public static T RestRequest <T>(string url, HttpRequestType httpRequestType, object requestObj = null)
{
HttpWebRequest request;
if (httpRequestType == HttpRequestType.GET && requestObj == null)
{
request = GetGetRequest(url);
}
else if (httpRequestType == HttpRequestType.POST)
{
request = GetPostRequest(url, requestObj);
}
else if (httpRequestType == HttpRequestType.GET)
{
request = GetGetRequest(url, requestObj);
}
else
{
throw new ApplicationException("httpRequest type is unknown");
}
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls;
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
Stream receiveStream = response.GetResponseStream();
StreamReader readStream = new StreamReader(receiveStream, Encoding.UTF8);
string responseText = readStream.ReadToEnd();
response.Close();
readStream.Close();
T serialized = JsonConvert.DeserializeObject <T>(responseText);
return(serialized);
}
public String makeRequest(HttpRequestType type, String request)
{
if (type != HttpRequestType.GET && type != HttpRequestType.DELETE)
{
throw new ArgumentException("Must be a GET or DELETE");
}
WebRequest wr = WebRequest.Create(String.Concat(this.BaseUri, request));
wr.Method = Enum.GetName(typeof(HttpRequestType), type);
// HttpWebResponse response = (HttpWebResponse)wr.GetResponse();
using (HttpWebResponse response = (HttpWebResponse)wr.GetResponse())
{
using (StreamReader rdr = new StreamReader(response.GetResponseStream()))
{
if (response.StatusCode == HttpStatusCode.OK)
{
String responseBody = rdr.ReadToEnd();
return responseBody;
}
else
{
return response.StatusCode.ToString();
// TODO - handle error
}
}
}
}
public String postOrPut(HttpRequestType type, String body)
{
if (type != HttpRequestType.POST && type != HttpRequestType.PUT)
{
throw new ArgumentException("Must be a POST or PUT");
}
WebRequest wr = WebRequest.Create(this.BaseUri);
wr.Method = Enum.GetName(typeof(HttpRequestType), type);
byte[] bytesToSend = System.Text.Encoding.UTF8.GetBytes(body);
wr.ContentLength = bytesToSend.Length;
wr.ContentType = "application/x-www-form-urlencoded";
using (Stream writer = wr.GetRequestStream())
{
writer.Write(bytesToSend, 0, bytesToSend.Length);
}
using (HttpWebResponse response = (HttpWebResponse)wr.GetResponse())
{
using (StreamReader rdr = new StreamReader(response.GetResponseStream()))
{
if (response.StatusCode == HttpStatusCode.OK)
{
String responseBody = rdr.ReadToEnd();
return responseBody;
}
else
{
return response.StatusCode.ToString();
// TODO - handle error
}
}
}
}
public String postOrPut(HttpRequestType type, String body)
{
if (type != HttpRequestType.POST && type != HttpRequestType.PUT)
{
throw new ArgumentException("Must be a POST or PUT");
}
WebRequest wr = WebRequest.Create(this.BaseUri);
wr.Method = Enum.GetName(typeof(HttpRequestType), type);
byte[] bytesToSend = System.Text.Encoding.UTF8.GetBytes(body);
wr.ContentLength = bytesToSend.Length;
wr.ContentType = "application/x-www-form-urlencoded";
using (Stream writer = wr.GetRequestStream())
{
writer.Write(bytesToSend, 0, bytesToSend.Length);
}
using (HttpWebResponse response = (HttpWebResponse)wr.GetResponse())
{
using (StreamReader rdr = new StreamReader(response.GetResponseStream()))
{
if (response.StatusCode == HttpStatusCode.OK)
{
String responseBody = rdr.ReadToEnd();
return(responseBody);
}
else
{
return(response.StatusCode.ToString());
// TODO - handle error
}
}
}
}
public String makeRequest(HttpRequestType type, String request)
{
if (type != HttpRequestType.GET && type != HttpRequestType.DELETE)
{
throw new ArgumentException("Must be a GET or DELETE");
}
WebRequest wr = WebRequest.Create(String.Concat(this.BaseUri, request));
wr.Method = Enum.GetName(typeof(HttpRequestType), type);
// HttpWebResponse response = (HttpWebResponse)wr.GetResponse();
using (HttpWebResponse response = (HttpWebResponse)wr.GetResponse())
{
using (StreamReader rdr = new StreamReader(response.GetResponseStream()))
{
if (response.StatusCode == HttpStatusCode.OK)
{
String responseBody = rdr.ReadToEnd();
return(responseBody);
}
else
{
return(response.StatusCode.ToString());
// TODO - handle error
}
}
}
}
private void ProcessQuery(string query)
{
HeaderFields = ParseQuery(query);
if (HeaderFields == null || !HeaderFields.ContainsKey("Host"))
{
SendBadRequest();
return;
}
int port;
string host;
int ret;
if (HttpRequestType.ToUpper().Equals("CONNECT"))
{ //HTTPS
ret = RequestedPath.IndexOf(":", StringComparison.Ordinal);
if (ret >= 0)
{
host = RequestedPath.Substring(0, ret);
port = RequestedPath.Length > ret + 1 ? int.Parse(RequestedPath.Substring(ret + 1)) : 443;
}
else
{
host = RequestedPath;
port = 443;
}
}
else
{ //HTTP
ret = HeaderFields["Host"].IndexOf(":", StringComparison.Ordinal);
if (ret > 0)
{
host = HeaderFields["Host"].Substring(0, ret);
port = int.Parse(HeaderFields["Host"].Substring(ret + 1));
}
else
{
host = HeaderFields["Host"];
port = 80;
}
if (HttpRequestType.ToUpper().Equals("POST"))
{
var index = query.IndexOf("\r\n\r\n", StringComparison.Ordinal);
_httpPost = query.Substring(index + 4);
}
}
try
{
var destinationEndPoint = new IPEndPoint(Dns.GetHostEntry(host).AddressList[0], port);
DestinationSocket = new Socket(destinationEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
if (HeaderFields.ContainsKey("Proxy-Connection") && HeaderFields["Proxy-Connection"].ToLower().Equals("keep-alive"))
{
DestinationSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, 1);
}
DestinationSocket.BeginConnect(destinationEndPoint, OnConnected, DestinationSocket);
}
catch
{
SendBadRequest();
}
}
public static string RestRequestWithStringResponse(string url, HttpRequestType httpRequestType, object requestObj)
{
HttpWebRequest request;
if (httpRequestType == HttpRequestType.GET && requestObj == null)
{
request = GetGetRequest(url);
}
else if (httpRequestType == HttpRequestType.POST)
{
request = GetPostRequest(url, requestObj);
}
else if (httpRequestType == HttpRequestType.GET)
{
request = GetGetRequest(url, requestObj);
}
else
{
throw new ApplicationException("httpRequest type is unknown");
}
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
Stream receiveStream = response.GetResponseStream();
StreamReader readStream = new StreamReader(receiveStream, Encoding.UTF8);
string responseText = readStream.ReadToEnd();
response.Close();
readStream.Close();
return(responseText);
}
public IEnumerable <T> Requests(HttpRequestType requestType, string url, object param = null, string token = null)
{
try
{
var result = new List <T>();
var ResponseString = ProcessRequest(requestType, url, param, token);
var jsonObject = (JObject)JsonConvert.DeserializeObject(ResponseString);
if (jsonObject["Results"] != null)
{
result = JsonConvert.DeserializeObject <List <T> >(jsonObject["Results"].ToString());
}
else
{
result = JsonConvert.DeserializeObject <List <T> >(jsonObject.ToString());
}
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
private void OnConnected(IAsyncResult ar)
{
try
{
if (DestinationSocket == null)
{
return;
}
string str;
DestinationSocket.EndConnect(ar);
if (HttpRequestType.ToUpper().Equals("CONNECT"))
{
if (ClientSocket != null)
{
str = HttpVersion + " 200 Connection established\r\n\r\n";
ClientSocket.BeginSend(Encoding.ASCII.GetBytes(str), 0, str.Length, SocketFlags.None, OnOkSent,
ClientSocket);
}
}
else
{
str = RebuildQuery();
DestinationSocket.BeginSend(Encoding.ASCII.GetBytes(str), 0, str.Length, SocketFlags.None,
OnQuerySent, DestinationSocket);
}
}
catch
{
Dispose();
}
}
private string ProcessRequest(HttpRequestType requestType, string url, object param = null, string token = null)
{
HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
if (token != null)
{
httpWebRequest.Headers.Add("Authorization", "Bearer " + token);
}
if (requestType != HttpRequestType.GET)
{
httpWebRequest.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
httpWebRequest.ContentType = "application/json";
httpWebRequest.Method = requestType.GetString();
using (var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream()))
{
streamWriter.Write(JsonConvert.SerializeObject(param));
}
}
string ResponseString = "";
var httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
ResponseString = streamReader.ReadToEnd();
}
return(ResponseString);
}
public static string GetString(this HttpRequestType requestType)
{
string result = string.Empty;
switch (requestType)
{
case HttpRequestType.GET:
result = Global.Method.GET;
break;
case HttpRequestType.POST:
result = Global.Method.POST;
break;
case HttpRequestType.PUT:
result = Global.Method.PUT;
break;
case HttpRequestType.DELETE:
result = Global.Method.DELETE;
break;
default:
break;
}
return(result);
}
private void OnConnected(IAsyncResult ar)
{
try
{
DestinationSocket.EndConnect(ar);
string rq;
if (HttpRequestType.ToUpper().Equals("CONNECT"))
{ //HTTPS
rq = HttpVersion + " 200 Connection established\r\nProxy-Agent: DoctorProxy Proxy Server\r\n\r\n";
ClientSocket.BeginSend(Encoding.ASCII.GetBytes(rq), 0, rq.Length, SocketFlags.None, new AsyncCallback(this.OnOkSent), ClientSocket);
}
else
{ //Normal HTTP
rq = RebuildQuery();
//اینجا لاگ کن
DestinationSocket.BeginSend(Encoding.ASCII.GetBytes(rq), 0, rq.Length, SocketFlags.None, new AsyncCallback(this.OnQuerySent), DestinationSocket);
}
}
catch (Exception ex)
{
Log.Write(MethodInfo.GetCurrentMethod(), ex);
Dispose();
}
}
private UnityWebRequest CreateWebReqeust(HttpRequestType requestType, ref string requestURL, ref HTTPParam data, int timeOut)
{
UnityWebRequest engine = default;
switch (requestType)
{
case HttpRequestType.Get:
string GETParam = HttpUtility.GetOriginalDataString(data);
engine = CreateRequesterGET(ref requestURL, ref GETParam);
break;
case HttpRequestType.Post:
InitURLRequestBasic();
engine = CreateRequesterPOST(ref requestURL, ref data);
break;
}
if (engine != default)
{
engine.timeout = timeOut;
}
else
{
}
return(engine);
}
private UnityWebRequest CreateWebReqeust(HttpRequestType requestType, ref string requestURL, ref JsonData data, int timeOut)
{
UnityWebRequest engine = default;
switch (requestType)
{
case HttpRequestType.Get:
string GETParam = JsonMapper.ToJson(data);
engine = CreateRequesterGET(ref requestURL, ref GETParam);
break;
case HttpRequestType.Post:
InitURLRequestBasic();
engine = CreateRequesterPOSTByJSON(ref requestURL, ref data);
break;
}
if (engine != default)
{
engine.timeout = timeOut;
}
else
{
}
return(engine);
}
/// <summary>
/// 发送以Json对象为参数的请求
/// </summary>
/// <param name="requestType"></param>
/// <param name="requestURL"></param>
/// <param name="successResponse"></param>
/// <param name="errorResponse"></param>
/// <param name="data"></param>
/// <param name="timeOut"></param>
/// <param name="showWaiting"></param>
/// <param name="callback"></param>
/// <param name="apiValue"></param>
public void JsonDataRequest(
HttpRequestType requestType, string requestURL, OnSuccess successResponse, OnError errorResponse, JsonData data = default,
int timeOut = 10, bool showWaiting = true, OnSuccess callback = default, string apiValue = "")
{
HTTPJsonRequestInfo info = new HTTPJsonRequestInfo
{
requestType = requestType,
requestURL = requestURL,
successResponse = successResponse,
errorResponse = errorResponse,
data = data,
timeOut = timeOut,
showWaiting = showWaiting,
callback = callback,
headerAPI = apiValue
};
if (showWaiting)
{
mRequestInfoList.Add(info);
}
else
{
mRequestInfosNoWaiting.Add(info);
}
}
private IEnumerator SendRequest(HttpRequestType requestType, string requestURL, OnSuccess successResponse, OnErrorResponse errorResponse, HTTPParam data = default, int timeOut = 10, string headerAPIValue = "")
{
string debug = string.Empty;
DateTime debugTime = DateTime.UtcNow;
LogBeforeSend(ref debug, ref requestType, ref requestURL, ref data);
UnityWebRequest engine = CreateWebReqeust(requestType, ref requestURL, ref data, timeOut);
InitAndSetHeaderAPI(ref engine, headerAPIValue);//标记HTTP请求头部数据，区分发送同一个请求的不同业务
mIsNetWorking = true;
yield return(engine.SendWebRequest());
mIsNetWorking = false;
LogTimeUsed(ref debug, ref engine, debugTime);
string headerAPI = engine.GetRequestHeader("api");
CheckRequestError(ref engine, ref debug, out int errorStatu);
Responsed(errorStatu, ref engine, successResponse, errorResponse, ref data, ref requestURL, ref debug);
engine.Dispose();
RemoveHeaderAPI(ref headerAPI);
}
// TODO: simplify timeout for Unity 5.6+
// https://docs.unity3d.com/ScriptReference/Networking.UnityWebRequest-timeout.html
public HTTPRequest(string url, Action <Response> callback, int timeout, HttpRequestType requestType = HttpRequestType.Get)
{
IsCompleted = false;
_requestType = requestType;
switch (_requestType)
{
case HttpRequestType.Get:
_request = UnityWebRequest.Get(url);
break;
case HttpRequestType.Head:
_request = UnityWebRequest.Head(url);
break;
default:
_request = UnityWebRequest.Get(url);
break;
}
_request.timeout = timeout;
_callback = callback;
#if UNITY_EDITOR
if (!EditorApplication.isPlaying)
{
Runnable.EnableRunnableInEditor();
}
#endif
Runnable.Run(DoRequest());
}
/// <summary>
/// HTTP请求（异步）
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="type">请求类型</param>
/// <param name="url">请求地址</param>
/// <param name="requestParas">请求参数（json格式）</param>
/// <param name="timeout">请求超时时间</param>
/// <param name="headerDic">请求头</param>
/// <param name="cookie">请求时携带的cookie</param>
/// <param name="referrer">伪造http_referer</param>
/// <param name="ensureSuccess">如果 HTTP 响应的 System.Net.Http.HttpResponseMessage.IsSuccessStatusCode 属性为 false，是否引发异常。</param>
/// <param name="httpRequestResultType"></param>
/// <returns></returns>
public static async Task <T> RequestAsync <T>(HttpRequestType type, string url, string requestParas = null, TimeSpan?timeout = null, IDictionary <string, string> headerDic = null, string cookie = null, string referrer = null, bool ensureSuccess = true, HttpRequestResultType httpRequestResultType = HttpRequestResultType.Json) where T : class, new()
{
if (string.IsNullOrWhiteSpace(url))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(url));
}
var requestResult = await RequestAsync(HttpRequestType.Post, url, requestParas, timeout, headerDic, cookie, referrer, ensureSuccess);
if (string.IsNullOrWhiteSpace(requestResult))
{
return(default(T));
}
T result;
switch (httpRequestResultType)
{
case HttpRequestResultType.Json:
result = JsonHelper.Deserialize <T>(requestResult);
break;
case HttpRequestResultType.Xml:
result = XmlSerializer <T> .Instance.Deserialize(requestResult);
break;
default:
throw new Exception($"Unsupported HttpRequestResultType: {httpRequestResultType.ToString()}");
}
return(result);
}
protected HttpWebRequest CreateHttpWebRequest(string url, HttpRequestType requestType)
{
var request = (HttpWebRequest)WebRequest.Create(url);
request.Method = requestType.ToString().ToUpper();
request.UserAgent = _userAgent;
request.KeepAlive = false;
return request;
}
/// <summary>
/// 获取HTTP请求方法
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private static HttpMethod GetHttpMethod(HttpRequestType type)
{
if (!_requestTypeMapDic.ContainsKey(type))
{
throw new Exception($"Unsupported HttpRequestType: {type.ToString()}");
}
return(_requestTypeMapDic[type]);
}
protected HttpWebRequest CreateHttpWebRequest(string url, HttpRequestType requestType)
{
var request = (HttpWebRequest)WebRequest.Create(url);
request.Method = requestType.ToString().ToUpper();
request.UserAgent = _userAgent;
request.KeepAlive = false;
return(request);
}
private bool IsValidQuery(string query)
{
if (String.IsNullOrEmpty(query))
{
return(false);
}
HeaderFields = ParseQuery(query);
return(!HttpRequestType.ToUpper().Equals("POST") || !HeaderFields.ContainsKey("Content-Length"));
}
private async Task <HttpResponseMessage> InternalRequestAsync(HttpRequestType httpRequestType, string requestUri, HttpContent httpContent, Dictionary <string, string> headers, string accessToken)
{
_appHttpClient.DefaultRequestHeaders.Clear();
_appHttpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(KnownMimeTypes.Json));
if (headers != null)
{
foreach (var header in headers)
{
_appHttpClient.DefaultRequestHeaders.Add(header.Key, header.Value);
}
}
if (!string.IsNullOrEmpty(accessToken))
{
_appHttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
}
var response = await _appHttpClient.RequestAsync(httpRequestType, requestUri, httpContent);
var statusCode = (int)response.StatusCode;
if (response.IsSuccessStatusCode)
{
if (statusCode == 204)
{
throw new NoContentException("No content available.");
}
return(response);
}
else
{
if (statusCode == 400)
{
var badRequestContract = await _httpMessageHelper.DecodeJsonResponseToObject <BadRequestResponseContract>(response);
if (badRequestContract != null && !string.IsNullOrEmpty(badRequestContract.Message))
{
throw new ServerMessageException(badRequestContract.Message);
}
}
var method = httpRequestType.ToString().ToUpper();
if (statusCode >= 500)
{
throw new ServerErrorException("Server is unavailable.", new ApiException($"{method} request failed for endpoint {requestUri}.", method, statusCode, response.ReasonPhrase));
}
else
{
var errorData = await _httpMessageHelper.DecodeJsonResponseToObject <Dictionary <string, object> >(response);
throw new ApiException($"{method} request failed.", method, statusCode, response.ReasonPhrase, new ApiErrorData(errorData));
}
}
}
public HttpRequest(Uri uri, HttpRequestType httpRequestType, HttpContent httpContent = null, NameValueCollection parameters = null)
{
Uri = uri;
HttpRequestType = httpRequestType;
HttpContent = httpContent;
if (parameters == null)
{
parameters = new NameValueCollection();
}
Parameters = parameters;
}
private void BeforeRequest(ref HTTPJsonRequestInfo info, out string requestURL, out JsonData data, out UnityWebRequest engine, ref string debug)
{
data = info.data;
requestURL = info.requestURL;
HttpRequestType requestType = info.requestType;
LogBeforeSend(ref debug, ref requestType, ref requestURL, ref data);
engine = CreateWebReqeust(requestType, ref requestURL, ref data, info.timeOut);
InitAndSetHeaderAPI(ref engine, info.headerAPI);//标记HTTP请求头部数据，区分发送同一个请求的不同业务
}
/// <summary>
/// Creates and returns a <see cref="IRequestSender"/> that can send out a specified <see cref="HttpRequestType"/>.
/// </summary>
/// <param name="requestType">The request type a sender is needed for.</param>
/// <returns>A new sender.</returns>
public static IRequestSender ManufactureRequestSender(HttpRequestType requestType)
{
switch (requestType)
{
case HttpRequestType.GET:
return new GetSender();
case HttpRequestType.POST:
return new PostSender();
default:
throw new NotImplementedException("There is no known sender implemented for the specified request type.");
}
}
public void CreateClientRequest(HttpRequestType requestType, string path)
{
ExecuteProtected(() =>
{
_requestSent = false;
var request = CreateRequest();
request.Url = $"{_config.BaseUrl}/{path}";
request.RequestType = requestType;
request.Headers = _headers;
ValidateRequest(request);
SendHttpRequestAsync(request).Wait();
});
}
public static TResult RESTfulRequest <TResult>(string url, HttpRequestType method, string authorization = null, string input = null, string contentType = null) where TResult : class, new()
{
var responseResult = RESTfulRequest(url, method, input, authorization, contentType);
if (string.IsNullOrEmpty(responseResult))
{
return(null);
}
else
{
return(JsonConvert.DeserializeObject <TResult>(responseResult));
}
}
public static Bitmap GetImage(string carrier, string target, string refere, ref string cookie, HttpRequestType method, Encoding encoding, int timeOut, bool keepAlive, params string[] parameters)
{
return null;
}
private void btnSave_Click(object sender, System.EventArgs e)
{
if ( this.txtUrl.Text.Length == 0 )
{
this.errorProvider1.SetError(txtUrl, "A url is required.");
}
else
{
_selectedRequestType = (HttpRequestType)Enum.Parse(typeof(HttpRequestType),(string)combo.SelectedValue);
this.DialogResult = DialogResult.OK;
this.Close();
}
}
/// <summary>
/// Creates a new ResponseBuffer.
/// </summary>
/// <param name="requestType"> The request type of the response buffer.</param>
public ResponseBuffer(HttpRequestType requestType)
{
this.RequestType = requestType;
}
/// <summary>
/// Creates a new web request.
/// </summary>
/// <param name="httpRequestType"> The HTTP request type.</param>
/// <param name="url"> The url.</param>
/// <returns> A new web request.</returns>
public static WebRequest Create(HttpRequestType httpRequestType, string url)
{
WebRequest request = null;
switch ( httpRequestType )
{
case HttpRequestType.GET:
request = new GetWebRequest();
request.Url = url;
break;
case HttpRequestType.POST:
request = new PostWebRequest();
request.Url = url;
break;
case HttpRequestType.PUT:
request = new PutWebRequest();
request.Url = url;
break;
case HttpRequestType.DELETE:
request = new DeleteWebRequest();
request.Url = url;
break;
case HttpRequestType.SOAPHTTP:
request = new SoapHttpWebRequest();
request.Url = url;
break;
}
return request;
}
public override HttpResponseMessage Execute(HttpRequestType requestType, Uri uri = null, string relativeUri = null, string content = null, int waitMillis = 0, int retryCount = 0)
{
try
{
var response = ExecuteAsync(requestType, uri, relativeUri, content, waitMillis).Result;
// Handle any errors
try
{
OktaExceptionResolver.ParseHttpResponse(response);
}
// If it's a rate-limiting error
catch (OktaRequestThrottlingException e)
{
// If we haven't met the retry threshold
if (waitMillis < Constants.MaxThrottlingRetryMillis * 1000)
{
// If this is our second retry, then we need to scale back
if (retryCount > 0)
{
// Use exponential backoff
int millis = (int)Math.Pow(2, retryCount) * 1000;
return Execute(requestType, uri, relativeUri, content, millis, retryCount: retryCount++);
}
else
{
// Determine the number of milliseconds to wait using the header
IEnumerable<string> resetValues;
if (!response.Headers.TryGetValues("X-Rate-Limit-Reset", out resetValues))
{
// TODO: Log that we were unable to get the reset pageSize
throw e;
}
else
{
// Parse the string header to an int
var waitUntilString = resetValues.FirstOrDefault();
int waitUntilUnixTime;
if (!int.TryParse(waitUntilString, out waitUntilUnixTime))
{
// TODO: Log that we were unable to convert the header
throw e;
}
else
{
// See how long until we hit that time
var unixTime = (Int64)DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalMilliseconds;
var millisToWait = unixTime - ((Int64)waitUntilUnixTime * 1000);
if (millisToWait > Int32.MaxValue)
{
// TODO: Log that we miscalculated the wait time
throw e;
}
// Then attempt to send the request again
return Execute(requestType, uri, relativeUri, content, (int)millisToWait, retryCount: 1);
}
}
}
}
else
{
// TODO: Log that there are too many requests queued
throw e;
}
}
// If there were no errors, just return
return response;
}
catch (OktaException e)
{
throw e;
}
catch (Exception e)
{
throw new OktaException("Error making an HTTP request: " + e.Message, e);
}
}
public override Task<HttpResponseMessage> ExecuteAsync(HttpRequestType requestType, Uri uri = null, string relativeUri = null, string content = null, int waitMillis = 0)
{
// Ensure we have exactly one useable Uri
if (String.IsNullOrEmpty(relativeUri) && uri == null)
{
throw new OktaException("Cannot execute an Http request without a Uri");
}
else if (!String.IsNullOrEmpty(relativeUri) && uri != null)
{
throw new OktaException("Http request is ambiguous: cannot determine whether to execute " + uri.ToString() + " or " + relativeUri);
}
try
{
// Wait
Utils.Sleep(waitMillis);
// Handle GETs
if (requestType == HttpRequestType.GET)
{
if (uri != null)
{
return httpClient.GetAsync(uri);
}
else
{
return httpClient.GetAsync(relativeUri);
}
}
// Handle POSTs
else if (requestType == HttpRequestType.POST)
{
content = content ?? "";
if (uri != null)
{
return httpClient.PostAsync(uri, new StringContent(content, Encoding.UTF8, "application/json"));
}
else
{
return httpClient.PostAsync(relativeUri, new StringContent(content, Encoding.UTF8, "application/json"));
}
}
// Handle PUTs
else if (requestType == HttpRequestType.PUT)
{
content = content ?? "";
if (uri != null)
{
return httpClient.PutAsync(uri, new StringContent(content, Encoding.UTF8, "application/json"));
}
else
{
return httpClient.PutAsync(relativeUri, new StringContent(content, Encoding.UTF8, "application/json"));
}
}
// Handle DELETEs
else if (requestType == HttpRequestType.DELETE)
{
if (uri != null)
{
return httpClient.DeleteAsync(uri);
}
else
{
return httpClient.DeleteAsync(relativeUri);
}
}
else
{
throw new OktaException("The " + requestType.ToString() + " http verb is not yet supported");
}
}
catch (OktaException e)
{
throw e;
}
catch (Exception e)
{
throw new OktaException("Error making an HTTP request: " + e.Message, e);
}
}
public static Bitmap GetImage(string carrier, string target, string refere, ref string cookie, HttpRequestType method)
{
return Http.GetImage(carrier, target, refere, ref cookie, method, Encoding.GetEncoding("gb2312"), 60, true, new string[0]);
}
public static Stream GetStream(string target, string refere, ref string cookie, HttpRequestType method, Encoding encoding, int timeOut, bool keepAlive, params string[] parameters)
{
HttpWebResponse response = null;
Stream responseStream = null;
Stream returnStream = null;
try
{
string ps = string.Empty;
if (parameters != null && parameters.Length >= 1)
{
ps = string.Join("&", parameters);
}
byte[] bytes = encoding.GetBytes(ps);
string urlPath = string.Empty;
if (method == HttpRequestType.GET)
{
if (target.IndexOf("randCode.jsp?che=") < 0)
{
urlPath = string.Format("{0}?{1}", target, ps);
}
else
{
urlPath = target;
}
}
else
{
urlPath = target;
}
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(urlPath);
HttpRequestCachePolicy policy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
request.CachePolicy = policy;
request.Timeout = timeOut * 1000;
request.KeepAlive = keepAlive;
request.Method = method.ToString().ToUpper();
bool isPost = request.Method.ToUpper() == "POST";
if (isPost)
{
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = (long)bytes.Length;
}
request.UserAgent = "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; SV1; .NET CLR 2.0.1124)";
request.Referer = refere;
request.Headers.Add("cookie", cookie);
request.Headers.Add("Cache-Control", "no-cache");
request.Accept = "*/*";
request.Credentials = CredentialCache.DefaultCredentials;
if (isPost)
{
Stream requestStream = request.GetRequestStream();
requestStream.Write(bytes, 0, bytes.Length);
requestStream.Close();
}
response = (HttpWebResponse)request.GetResponse();
responseStream = response.GetResponseStream();
byte[] buffer = Http.StreamToBytes(responseStream);
returnStream = new MemoryStream(buffer);
string outCookie = response.Headers.Get("Set-Cookie");
if (outCookie != null)
{
if (outCookie.Contains("JSESSIONID_3UB2B"))
{
outCookie = outCookie.Replace(",JSESSIONID_3UB2B=", "; JSESSIONID_3UB2B=");
}
else
{
if (outCookie.Contains("JSESSIONID_HOB2B"))
{
outCookie = outCookie.Replace(",JSESSIONID_HOB2B=", "; JSESSIONID_HOB2B=");
}
else
{
if (outCookie.Contains("JSESSIONID_BKB2B"))
{
outCookie = outCookie.Replace(",JSESSIONID_BKB2B=", "; JSESSIONID_BKB2B=");
}
else
{
if (outCookie.Contains("JSESSIONID_MFB2B"))
{
outCookie = outCookie.Replace(",JSESSIONID_MFB2B=", "; JSESSIONID_MFB2B=");
}
else
{
outCookie = outCookie.Replace(",JSESSIONID=", "; JSESSIONID=");
}
}
}
}
cookie = Http.SetCookies(cookie, outCookie);
}
}
finally
{
if (response != null)
{
response.Close();
}
if (responseStream != null)
{
responseStream.Close();
}
}
return returnStream;
}
public static async Task<HttpContent> Request(string token, string url, object data, HttpRequestType type)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("X-API-TOKENAUTH", token);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
try
{
HttpResponseMessage response = null;
switch (type)
{
case HttpRequestType.GET:
{
response = await client.GetAsync(url);
break;
}
case HttpRequestType.POST:
{
var param = JsonConvert.SerializeObject(data);
HttpContent contentPost = new StringContent(param, Encoding.UTF8, "application/json");
response = await client.PostAsync(url, contentPost);
break;
}
case HttpRequestType.PUT:
{
var param = JsonConvert.SerializeObject(data);
HttpContent contentPost = new StringContent(param, Encoding.UTF8, "application/json");
response = await client.PutAsync(url, contentPost);
break;
}
case HttpRequestType.DELETE:
{
response = await client.DeleteAsync(url);
break;
}
default:
throw new Exception("Unsupported Request Type");
}
response.EnsureSuccessStatusCode();
return response.Content;
}
catch (HttpRequestException requestException)
{
//if (requestException != null)
//{
// //var statusCode = requestException.
// var faceOffersError = new FaceOffersError();
// throw new FaceOffersException(statusCode, faceOffersError, faceOffersError.Message);
//}
throw;
}
}
}
public abstract Task<HttpResponseMessage> ExecuteAsync(HttpRequestType requestType, Uri uri = null, string relativeUri = null, string content = null, int waitMillis = 0);
public abstract HttpResponseMessage Execute(HttpRequestType requestType, Uri uri = null, string relativeUri = null, string content = null, int waitMillis = 0, int retryCount = 0);
