public CMessage(EMessageType Type, ERequestType RqsType, EDataType DataType, string Data) : this()
{
this.Type = Type;
this.RqsType = RqsType;
this.DataType = DataType;
this.Data = Data;
}
/// <summary>
/// Send query asynchronous
/// </summary>
/// <param name="requestType">Request type</param>
private void SendQueryAsync(ERequestType requestType)
{
int index = (int)requestType;
threads[index] = new Thread(() => SendQuery(requestType));
requestsRequired.SetLastRequestTime(requestType);
threads[index].Start();
}
internal Request(string fileName, EResourceType resourceType, ResourceManager.UnloadLevelFinishEventHandle handle, ERequestType requestType, ResourceAsyncOperation operation)
{
mFileName = fileName;
mResourceType = resourceType;
mHandleUnloadLevel = handle;
mRequestType = requestType;
mResourceAsyncOperation = operation;
}
// Token: 0x0600187B RID: 6267 RVA: 0x0008986C File Offset: 0x00087C6C
public IWebRequestHandle createRequest(string url, ERequestType requestType, WebRequestReadyCallback webRequestReadyCallback)
{
HTTPRequestHandle newHTTPRequestHandle = SteamHTTP.CreateHTTPRequest((requestType != ERequestType.GET) ? EHTTPMethod.k_EHTTPMethodPOST : EHTTPMethod.k_EHTTPMethodGET, url);
SteamworksWebRequestHandle steamworksWebRequestHandle = new SteamworksWebRequestHandle(newHTTPRequestHandle, webRequestReadyCallback);
this.steamworksWebRequestHandles.Add(steamworksWebRequestHandle);
return(steamworksWebRequestHandle);
}
/// <summary>
/// Send query when expired
/// </summary>
/// <param name="requestType">Request type</param>
/// <param name="milliseconds">Milliseconds</param>
public void SendQueryWhenExpired(ERequestType requestType, uint milliseconds)
{
uint t = (uint)(DateTime.Now.Subtract(requestsRequired.GetLastRequestTime(requestType)).TotalMilliseconds);
if (t >= milliseconds)
{
SendQueryAsync(requestType);
}
}
internal ResourceAsyncOperation(ERequestType requestType)
{
mRequestType = requestType;
mAllDependenciesAssetSize = 0; // 需要加载的资源总大小
mLoadedDependenciesAssetSize = 0;
mComplete = false;
asyncOperation = null;
mResource = null;
}
/// <summary>
/// Send query when required
/// </summary>
/// <param name="requestType">Request type</param>
/// <returns>Success</returns>
private bool SendQueryWhenRequired(ERequestType requestType)
{
bool ret = true;
if (requestsRequired[requestType])
{
ret = SendQuery(requestType);
}
return(ret);
}
/// <summary>
/// Abort thread
/// </summary>
/// <param name="requestType"></param>
private void AbortThread(ERequestType requestType)
{
lock (threads)
{
int index = (int)requestType;
if (threads[index] != null)
{
threads[index].Abort();
threads[index] = null;
}
}
}
/// <summary>
/// Array element access operator
/// </summary>
/// <param name="requestType">Request type</param>
/// <returns>Request required</returns>
public bool this[ERequestType requestType]
{
get
{
return(values[(int)requestType]);
}
set
{
if (available[(int)requestType])
{
values[(int)requestType] = value;
}
}
}
public static RequestResult GetPage(string Uri, string UriReferer, ERequestType Method, string Params)
{
List <string> newParams = new List <string>();
Params = Params.Trim();
if (Params.Length > 0)
{
foreach (string splitPair in Params.Split('&'))
{
newParams.AddRange(splitPair.Split('='));
}
}
return(GetPage(Uri, UriReferer, Method, newParams));
}
public void initializeFriendsController(ERequestType requestType, List <object> gameFriends, EFriendsType friendType)
{
switch (requestType)
{
case ERequestType.ASK_KEYS:
initializeFriendsController(gameFriends, friendType);
currentRequestType = requestType;
break;
case ERequestType.ASK_LIFES:
initializeFriendsController(gameFriends, friendType);
currentRequestType = requestType;
break;
}
}
public async Task <IActionResult> Index(ERequestType requestType)
{
var response = await _targetService.CallTargetService(requestType);
var responseContent = JsonSerializer.Deserialize <ResponseModel>(response.Content.ReadAsStringAsync().Result,
new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true
});
if (response.StatusCode == HttpStatusCode.OK)
{
return(Ok(responseContent));
}
return(BadRequest(responseContent));
}
public static RequestResult GetPage(string Uri, string UriReferer, ERequestType Method, List <string> Params)
{
RequestHelper mClient;
mClient = new RequestHelper(Uri, UriReferer);
mClient.Type = Method;
if (Cookies != null)
{
mClient.Cookies.Add(Cookies);
}
for (int i = 0; i < Params.Count; i += 2)
{
mClient.RequestUrlValues.Add(Params[i], Params[i + 1]);
}
return(mClient.Request());
}
private void Throttle(ERequestType RequestType)
{
DateTime Timestamp = DateTime.Now;
if (this.Timings.ContainsKey(RequestType))
{
Tuple <int, int, int, int> Response = this.Timings[RequestType].Pour();
Task.Run(() =>
{
this.OnCallThrottle(RequestType, Timestamp, Response.Item1, Response.Item2, Response.Item3, Response.Item4);
});
}
else
{
throw new NotImplementedException($"Error, the request type [{RequestType}] has not yet been implemented properly into the leaky bucket system!");
}
}
public void openFriendsRequestPanel(ERequestType requestType, EFriendsType friendsType = EFriendsType.ALL)
{
checkImageExist(friendsType);
allFriendsSR.normalizedPosition = Vector2.zero;
gameFriendsSR.normalizedPosition = Vector2.zero;
switch (requestType)
{
case ERequestType.ASK_KEYS:
requestText.text = MultiLanguageTextManager.instance.getTextByID(MultiLanguageTextManager.BOSS_LOCKED_KEY_TEXT);
currentRequestType = requestType;
break;
case ERequestType.ASK_LIFES:
requestText.text = MultiLanguageTextManager.instance.getTextByID(MultiLanguageTextManager.FULL_LIFES_POPUP_BUTTON);
currentRequestType = requestType;
break;
}
}
/// <summary>
/// Send query
/// </summary>
/// <param name="requestType">Request type</param>
/// <returns>Success</returns>
private bool SendQuery(ERequestType requestType)
{
bool ret = false;
requestsRequired.SetLastRequestTime(requestType);
try
{
EndPoint endpoint = new IPEndPoint(IPAddress, Port);
using (MemoryStream stream = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(stream))
{
char op_code = RequestsRequired.GetOpCode(requestType);
writer.Write("SAMP".ToCharArray());
writer.Write(ipv4AddressUInt);
writer.Write(port);
writer.Write(op_code);
if (op_code == 'p')
{
Random r = new Random();
r.NextBytes(randomNumbers);
writer.Write(randomNumbers);
}
timestamp[0] = DateTime.Now;
}
if (socket.SendTo(stream.ToArray(), endpoint) > 0)
{
ret = true;
Receive();
}
}
}
catch
{
//
}
return(ret);
}
/// <summary>
/// Get last request time
/// </summary>
/// <param name="requestType">Request type</param>
/// <returns>Last request time</returns>
public DateTime GetLastRequestTime(ERequestType requestType)
{
return(lastRequestTime[(int)requestType]);
}
protected void Throttle(ERequestType RequestType)
{
this._ThrottleRequest(RequestType);
}
/// <summary>
/// Get operation code
/// </summary>
/// <param name="requestType">Request type</param>
/// <returns>Operation code</returns>
public static char GetOpCode(ERequestType requestType)
{
return(opCodes[(int)requestType]);
}
public static async Task <T> RequestInternalJson <T>(string request, object requestData, AuthTokens token = null, ERequestType type = ERequestType.POST, string apiString = "https://chat.apianon.ru/")
{
string resultQuerry = apiString + request;
//var httpRequestMessage = new HttpRequestMessage()
//{
// RequestUri = new Uri(resultQuerry),
// Headers = {
// { "X-Auth-Token", token.Token },
// { "X-User-Id", token.UserId },
// }
//};
//switch(type)
//{
// case ERequestType.GET:
// httpRequestMessage.Method = HttpMethod.Get;
// break;
// case ERequestType.POST:
// default:
// httpRequestMessage.Content = new StringContent(JsonConvert.SerializeObject(requestData));
// httpRequestMessage.Method = HttpMethod.Post;
// break;
//}
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
if (token != null)
{
client.DefaultRequestHeaders.Add("X-Auth-Token", token.Token);
client.DefaultRequestHeaders.Add("X-User-Id", token.UserId);
//client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(token);
}
System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls;
var json = JsonConvert.SerializeObject(requestData);
var data = new StringContent(json, Encoding.UTF8, "application/json");
HttpResponseMessage response = new HttpResponseMessage();
switch (type)
{
case ERequestType.GET:
response = await client.GetAsync(resultQuerry);
break;
case ERequestType.POST:
default:
response = await client.PostAsync(resultQuerry, data);
break;
}
string result = response.Content.ReadAsStringAsync().Result;
T resp = JsonConvert.DeserializeObject <T>(result);
client.DefaultRequestHeaders.Clear();
return(resp);
}
/// <summary>
/// Lock
/// </summary>
/// <param name="requestType">Request type</param>
public void Lock(ERequestType requestType)
{
available[(int)requestType] = false;
values[(int)requestType] = false;
}
/// <summary>
/// Is data fetched
/// </summary>
/// <param name="requestType">Request type</param>
/// <returns>Data fetched</returns>
public bool IsDataFetched(ERequestType requestType)
{
return(!(requestsRequired[requestType]));
}
private void OnCallThrottleLog(ERequestType RequestType, DateTime CurrentTimestamp, int BucketCount, int MaxRequestQuota, int RestoreCount, int RestorePeriod)
{
Console.WriteLine($"Throttle Request: {RequestType,20}\tTimestamp: {CurrentTimestamp.ToString(),10}\tBucket/Quota: {BucketCount}/{MaxRequestQuota}\tRestore Count/Period: {RestoreCount}/{RestorePeriod}ms");
}
//todo
public ClientRequest(string userId, ERequestType type)
{
this.UserId = userId;
this.Type = type;
}
internal AmazonCallAttribute(ERequestType RequestType)
{
this.RequestType = RequestType;
}
/// <summary>
/// Fetch data asynchronous
/// </summary>
/// <param name="requestType">Request type</param>
public void FetchDataAsync(ERequestType requestType)
{
AbortThread(requestType);
requestsRequired[requestType] = true;
SendQueryAsync(requestType);
}
public CMessage(EMessageType Type, ERequestType RqsType) : this()
{
this.Type = Type;
this.RqsType = RqsType;
}
/// <summary>
/// Set last request time
/// </summary>
/// <param name="requestType">Request type</param>
public void SetLastRequestTime(ERequestType requestType)
{
lastRequestTime[(int)requestType] = DateTime.Now;
}
public async Task <HttpResponseMessage> CallTargetService(ERequestType requestType)
{
return(await _httpClient.GetAsync($"/?type={(int)requestType}"));
// return JsonSerializer.Deserialize<ResponseModel>(result, new JsonSerializerOptions(){PropertyNameCaseInsensitive = true});
}
private static DefaultResponse Request(ERequestType requestType, byte[] file = null)
{
string responseString = "";
string entityUrl = ParamConfig.URL_BASE + (file != null ? ParamConfig.PostUrl : ParamConfig.GetUrl) + ParamConfig.TOKEN;
var httpWebRequest = WebRequest.Create(entityUrl);
httpWebRequest.Method = requestType.ToString().ToUpper();
if (file != null)
{
httpWebRequest.ContentType = "multipart/form-data";
httpWebRequest.ContentLength = file.Length;
Stream dataStream = httpWebRequest.GetRequestStream();
dataStream.Write(file, 0, file.Length);
dataStream.Close();
}
else
{
httpWebRequest.ContentType = "application/json";
}
ServicePointManager.Expect100Continue = false;
ServicePointManager.SecurityProtocol = (SecurityProtocolType)192 | (SecurityProtocolType)768 | (SecurityProtocolType)3072;
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls;
try
{
using (var response = (HttpWebResponse)httpWebRequest.GetResponse())
{
using (Stream responseStream = response.GetResponseStream())
{
using (StreamReader streamReader = new StreamReader(responseStream))
{
responseString = streamReader.ReadToEnd();
return(new DefaultResponse()
{
status = EStatus.SUCCESS,
response = JsonConvert.DeserializeObject <ResponseObject>(responseString)
});
}
}
}
}
catch (Exception e)
{
if (e is WebException webException)
{
if (webException.Response != null)
{
using (var errorResponse = (HttpWebResponse)webException.Response)
using (var reader = new StreamReader(errorResponse.GetResponseStream()))
{
string error = reader.ReadToEnd();
return(new DefaultResponse()
{
status = EStatus.ERROR,
response = JsonConvert.DeserializeObject <ResponseObject>(responseString)
});
}
}
}
throw e;
}
}
