127 lines
4.9 KiB
Nim
127 lines
4.9 KiB
Nim
import parseutils, json, httpClient, strformat, tables, times, asyncdispatch
|
|
from discordobject import snowflake
|
|
|
|
proc getIDFromJson*(str: string): uint64 =
|
|
var num: uint64
|
|
discard parseBiggestUInt(str, num)
|
|
return num
|
|
|
|
proc parseIntEasy*(str: string): int =
|
|
var num: int
|
|
discard parseInt(str, num)
|
|
return num
|
|
|
|
proc endpoint*(url: string): string =
|
|
return fmt("https://discord.com/api/v6{url}")
|
|
|
|
var globalToken*: string
|
|
|
|
proc defaultHeaders*(added: HttpHeaders = newHttpHeaders()): HttpHeaders =
|
|
added.add("Authorization", fmt("Bot {globalToken}"))
|
|
added.add("User-Agent", "NimCord (https://github.com/SeanOMik/nimcord, v0.0.0)")
|
|
added.add("X-RateLimit-Precision", "millisecond")
|
|
return added;
|
|
|
|
type
|
|
RateLimitBucketType* = enum
|
|
channel,
|
|
guild,
|
|
webhook,
|
|
global
|
|
RateLimit = ref object {.requiresInit.}
|
|
limit: int
|
|
remainingLimit: int
|
|
ratelimitReset: float
|
|
|
|
proc newRateLimit(lmt: int = 500, remLmnt: int = 500, ratelmtReset: float = 0): RateLimit =
|
|
return RateLimit(limit: lmt, remainingLimit: remLmnt, ratelimitReset: ratelmtReset)
|
|
|
|
# Rate limit buckets
|
|
let channelRatelimitBucket = newTable[snowflake, RateLimit]()
|
|
let guildRatelimitBucket = newTable[snowflake, RateLimit]()
|
|
let webhookRatelimitBucket = newTable[snowflake, RateLimit]()
|
|
var globalRateLimit: RateLimit = newRateLimit()
|
|
|
|
proc handleRateLimits*(headers: HttpHeaders, objectID: snowflake, bucketType: RateLimitBucketType) =
|
|
var obj: RateLimit
|
|
if (headers.hasKey("x-ratelimit-global")):
|
|
obj = globalRateLimit
|
|
elif (headers.hasKey("x-ratelimit-limit")):
|
|
case bucketType:
|
|
of RateLimitBucketType.channel:
|
|
obj = channelRatelimitBucket[objectID]
|
|
discard
|
|
of RateLimitBucketType.guild:
|
|
obj = guildRatelimitBucket[objectID]
|
|
discard
|
|
of RateLimitBucketType.webhook:
|
|
obj = webhookRatelimitBucket[objectID]
|
|
discard
|
|
of RateLimitBucketType.global:
|
|
obj = globalRateLimit
|
|
discard
|
|
else:
|
|
return
|
|
|
|
discard parseInt(headers["x-ratelimit-limit"], obj.limit)
|
|
discard parseInt(headers["x-ratelimit-remaining"], obj.remainingLimit)
|
|
discard parseFloat(headers["x-ratelimit-reset"], obj.ratelimitReset)
|
|
|
|
|
|
proc handleResponse*(response: Response, objectID: snowflake, bucketType: RateLimitBucketType): JsonNode =
|
|
echo fmt("Received requested payload: {response.body}")
|
|
|
|
handleRateLimits(response.headers, objectID, bucketType)
|
|
|
|
return parseJson(response.body())
|
|
|
|
proc waitForRateLimits*(objectID: snowflake, bucketType: RateLimitBucketType) =
|
|
var rlmt: RateLimit
|
|
if (globalRateLimit.remainingLimit == 0):
|
|
rlmt = globalRateLimit
|
|
else:
|
|
case bucketType:
|
|
of RateLimitBucketType.channel:
|
|
if (channelRatelimitBucket.hasKey(objectID)):
|
|
rlmt = channelRatelimitBucket[objectID]
|
|
else:
|
|
channelRatelimitBucket.add(objectID, newRateLimit())
|
|
rlmt = channelRatelimitBucket[objectID]
|
|
of RateLimitBucketType.guild:
|
|
if (guildRatelimitBucket.hasKey(objectID)):
|
|
rlmt = guildRatelimitBucket[objectID]
|
|
else:
|
|
guildRatelimitBucket.add(objectID, newRateLimit())
|
|
rlmt = guildRatelimitBucket[objectID]
|
|
of RateLimitBucketType.webhook:
|
|
if (webhookRatelimitBucket.hasKey(objectID)):
|
|
rlmt = webhookRatelimitBucket[objectID]
|
|
else:
|
|
webhookRatelimitBucket.add(objectID, newRateLimit())
|
|
rlmt = webhookRatelimitBucket[objectID]
|
|
of RateLimitBucketType.global:
|
|
rlmt = globalRateLimit
|
|
|
|
if (rlmt != nil and rlmt.remainingLimit == 0):
|
|
let millisecondTime: float = rlmt.ratelimitReset * 1000 - epochTime() * 1000
|
|
|
|
if (millisecondTime > 0):
|
|
echo fmt("Rate limit wait time: {millisecondTime} miliseconds")
|
|
discard sleepAsync(millisecondTime)
|
|
|
|
proc sendRequest*(endpoint: string, httpMethod: HttpMethod, headers: HttpHeaders, objectID: snowflake = 0,
|
|
bucketType: RateLimitBucketType = global, jsonBody: JsonNode = nil): JsonNode =
|
|
var client = newHttpClient()
|
|
# Add headers
|
|
client.headers = headers
|
|
|
|
var strPayload: string
|
|
if (jsonBody == nil):
|
|
strPayload = ""
|
|
else:
|
|
strPayload = $jsonBody
|
|
echo "Sending ", httpMethod, " request, URL: ", endpoint, ", headers: ", $headers, " body: ", strPayload
|
|
|
|
waitForRateLimits(objectID, bucketType)
|
|
let response = client.request(endpoint, httpMethod, strPayload)
|
|
return handleResponse(response, objectId, bucketType) |