public void GetSingleUserTestWithRestReqLibDeserialized()
{
UserData expectedUserData = new UserData(2, "Janet", "Weaver", new Uri("https://s3.amazonaws.com/uifaces/faces/twitter/josephstein/128.jpg"));
UserData actualUserData = new RestReq().Get(YamlReader.GetValue("Single_user")).Param("id", "2").Execute <UserData>();
Assert.IsTrue(expectedUserData.Equals(actualUserData));
}
public async Task <dynamic> Push(RouteIdentifier routeId, string url, RestReq options)
{
Queue.Wait();
try
{
var temp = Manager.GlobalTimeout;
if (!Limited())
{
return(await MakeRequest(routeId, url, options));
}
// Let library users know they have hit a ratelimit
// this._manager.Rest.emit(RESTManagerEvents.Ratelimited, {
// timeToReset: this.TimeToReset,
// limit: this.limit,
// method: options.method,
// hash: this.hash,
// route: routeID.route,
// majorParameter: this.majorParameter
// });
Console.WriteLine("R8 LIMIT!");
await Task.Delay(Convert.ToInt32(TimeToReset()));
return(await MakeRequest(routeId, url, options));
}
finally
{
Queue.Shift();
}
}
public void MockTest1()
{
var response = new RestReq("http://localhost:1234")
.Get("api/users/2")
.Execute();
Assert.AreEqual(200, (int)response.StatusCode);
Assert.IsTrue(response.Content.Length > 0);
}
public void CreateUserTestRestReq()
{
IRestResponse response = new RestReq()
.Post("api/users")
.AddJsonBody("{'name':'morpheus','job': 'leader'}")
.Execute();
Console.WriteLine(response.Content);
}
public void GetSingleUserTestWithRestReqLib()
{
UserData expectedUserData = new UserData(2, "Janet", "Weaver", new Uri("https://s3.amazonaws.com/uifaces/faces/twitter/josephstein/128.jpg"));
IRestResponse response = new RestReq()
.Get(YamlReader.GetValue("Single_user"))
.Param("id", "2")
.Execute();
UserData actualUserData = JsonConvert.DeserializeObject <UserData>(response.Content);
Assert.IsTrue(expectedUserData.Equals(actualUserData));
Assert.AreEqual(200, (int)response.StatusCode);
}
public Task <dynamic> QueueRequest(RestReq request)
{
var routeId = GenerateRouteIdentifiers(request.Endpoint, request.Method.ToString());
var tryGetVal = Hashes.TryGetValue($"{request.Method.ToString()}-${routeId.Route}", out var hash);
if (tryGetVal == false)
{
hash = $"UnknownHash({routeId.Route})";
}
_queues.TryGetValue($"{hash}:{routeId.MajorParameter}", out var queue);
if (queue == null)
{
CreateQueue(hash, routeId.MajorParameter);
_queues.TryGetValue($"{hash}:{routeId.MajorParameter}", out queue);
}
var res = ResolveRequest(request);
var resolveOptions = new RestReq
{
Auth = request.Auth,
Data = res.Options.Body,
Endpoint = request.Endpoint,
Files = res.Options.Files,
Headers = JsonConvert.DeserializeObject <Dictionary <string, dynamic> >(
JsonConvert.SerializeObject(res.Options.Headers)),
Method = res.Options.Method,
Query = request.Query,
Reason = request.Reason
};
return(queue.Push(routeId, res.Url, resolveOptions));
}
private async Task <dynamic> MakeRequest(RouteIdentifier routeId, string url, RestReq options, int retries = 0)
{
var controller = new CancellationTokenSource();
var abortTimer = new Timer(Client.ClientOptions.RestOptions.Timeout.TotalMilliseconds)
{
AutoReset = false
};
abortTimer.Start();
abortTimer.Elapsed += (sender, args) =>
{
controller.Cancel();
abortTimer.Dispose();
};
IRestResponse res;
try
{
var restRequest = new RestRequest(url, DataFormat.Json)
{
Method = options.Method
};
if (options.Headers != null)
{
foreach (var header in options.Headers)
{
restRequest.AddHeader(header.Key, header.Value);
}
}
if (options.Files != null)
{
foreach (var file in options.Files)
{
restRequest.AddFile(file.Name, file.Writer, file.FileName, file.ContentLength, file.ContentType);
}
}
if (options.Data != null)
{
restRequest.AddJsonBody(options.Data);
}
switch (options.Method)
{
case Method.GET:
res = Manager.RestClient.Get(restRequest);
break;
case Method.POST:
res = Manager.RestClient.Post(restRequest);
break;
case Method.PUT:
res = Manager.RestClient.Put(restRequest);
break;
case Method.PATCH:
res = Manager.RestClient.Patch(restRequest);
break;
case Method.DELETE:
res = Manager.RestClient.Delete(restRequest);
break;
default:
res = Manager.RestClient.Get(restRequest);
break;
}
}
catch (Exception error)
{
Console.WriteLine(JsonConvert.SerializeObject(error));
// if (error.Source == 'AbortError' && retries !== this.manager.options.retries) return this.makeRequest(routeID, url, options, ++retries);
throw;
}
finally
{
abortTimer.Stop();
abortTimer.Dispose();
}
var retryAfter = 0;
var limit = res.Headers.ToArray().ToList().Find(x => x.Name == "x-ratelimit-limit");
var remaining = res.Headers.ToArray().ToList().Find(x => x.Name == "x-ratelimit-remaining");
var reset = res.Headers.ToArray().ToList().Find(x => x.Name == "x-ratelimit-reset-after");
var hash = res.Headers.ToArray().ToList().Find(x => x.Name == "x-ratelimit-bucket");
var retry = res.Headers.ToArray().ToList().Find(x => x.Name == "Retry-After");
var cloudflare = res.Headers.ToArray().ToList().Find(x => x.Name == "Via") != null;
Limit = limit != null?Convert.ToInt32(limit.Value) : int.MaxValue;
Remaining = remaining != null?Convert.ToInt32(remaining.Value) : int.MaxValue;
Reset = reset != null
? Convert.ToInt32(reset.Value) * 1000 + new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds() +
Client.ClientOptions.RestOptions.Offset
: new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds();
if (retry != null)
{
retryAfter = Convert.ToInt32(retry.Value) * (cloudflare ? 1000 : 1) +
Client.ClientOptions.RestOptions.Offset;
}
if (hash != null && Convert.ToString(hash.Value) != Hash)
{
// this.manager.rest.emit(RESTManagerEvents.Debug, `Bucket hash update: ${this.hash} => ${hash} for ${options.method}-${routeID.route}`);
if (!Manager.Hashes.ContainsKey($"{options.Method}-${routeId.Route}"))
{
Manager.Hashes.Add($"{options.Method}-${routeId.Route}", Convert.ToString(hash.Value));
}
}
if (res.Headers.ToArray().ToList().Find(x => x.Name == "x-ratelimit-global") != null)
{
Manager.GlobalTimeout = new Task <bool>(() => true);
Thread.Sleep(retryAfter);
Manager.GlobalTimeout = null;
}
if (res.IsSuccessful)
{
return(ParseResponse(res));
}
switch (res.StatusCode)
{
case HttpStatusCode.TooManyRequests:
// this.manager.rest.emit(RESTManagerEvents.Debug, `429 hit on route: ${routeID.route}\nRetrying after: ${retryAfter}ms`);
Console.WriteLine("R8 LIMIT!");
await Task.Delay(retryAfter);
return(await MakeRequest(routeId, url, options, retries));
case HttpStatusCode.InternalServerError when retries != Client.ClientOptions.RestOptions.Retries:
return(await MakeRequest(routeId, url, options, ++retries));
case HttpStatusCode.InternalServerError:
Console.WriteLine("ERROR BITCH!");
break;
default:
{
if (res.StatusCode != HttpStatusCode.BadRequest)
{
return(null);
}
var data = await ParseResponse(res);
Console.WriteLine("MALFORMED DATA!");
// throw new DiscordAPIError(data.message, data.code, res.status, options.method as string, url);
return(null);
}
}
return(null);
}
private ResolveRequestStruct ResolveRequest(RestReq request)
{
var query = new QueryString();
var querystring = "";
if (request.Query != null)
{
foreach (var(key, value) in request.Query)
{
if (value != null)
{
query.Add(key, value);
}
}
querystring = $"?{query}";
}
var url = querystring.Length != 0
? $"{_client.ClientOptions.RestOptions.ApiUrl}v{_client.ClientOptions.RestOptions.Version}/{request.Endpoint}/?{querystring}"
: $"{_client.ClientOptions.RestOptions.ApiUrl}v{_client.ClientOptions.RestOptions.Version}/{request.Endpoint}";
var headers = new HeaderOptions
{
UserAgent = "DiscordBot ($Disharp $0.0.1)",
XRateLimitPrecision = "second"
};
if (request.Auth)
{
if (_token == null)
{
throw new NullReferenceException(
"No bot token has been provided, and is required for the action you are trying to do.");
}
// Provide authorization headers
headers.Authorization = $"{_client.TokenType} {_token}";
}
if (request.Reason != null)
{
headers.XAuditLogReason = Uri.EscapeDataString(request.Reason);
}
var body = JsonConvert.SerializeObject(request.Data);
headers.ContentType = "application/json";
var options = new HttpOptions
{
Method = request.Method,
Headers = new HeaderOptions
{
Authorization = headers.Authorization,
ContentType = headers.ContentType,
UserAgent = headers.UserAgent,
XAuditLogReason = headers.XAuditLogReason,
XRateLimitPrecision = headers.XRateLimitPrecision
},
Body = body,
Files = request.Files
};
// Return the data needed for node-fetch
return(new ResolveRequestStruct
{
Url = url,
Options = options
});
}
