250 lines
8.4 KiB
GDScript
250 lines
8.4 KiB
GDScript
extends Node
|
|
|
|
const EndpointConfig := preload("res://scripts/autoload/api_endpoint_config.gd")
|
|
const DEFAULT_URL := "https://us3q.ranaze.com/api/access"
|
|
const REQUEST_TIMEOUT_SECONDS := 30.0
|
|
const POLL_INTERVAL_SECONDS := 3.0
|
|
const POLL_LIMIT := 200
|
|
const CHECKOUT_STORAGE_KEY := "ranaze_access_checkout_url"
|
|
|
|
signal status_changed(status: Dictionary)
|
|
signal operation_succeeded(message: String)
|
|
signal operation_failed(message: String)
|
|
signal checkout_started(purchase_id: String, checkout_url: String)
|
|
|
|
var api_url := DEFAULT_URL
|
|
var status: Dictionary = {}
|
|
var status_request: HTTPRequest
|
|
var action_request: HTTPRequest
|
|
var purchase_request: HTTPRequest
|
|
var poll_timer: Timer
|
|
var pending_action := ""
|
|
var request_token := ""
|
|
var active_purchase_id := ""
|
|
var poll_count := 0
|
|
var checkout_popup_opened := false
|
|
|
|
|
|
func _ready() -> void:
|
|
api_url = EndpointConfig.resolve(
|
|
str(ProjectSettings.get_setting("step3/access_api_url", DEFAULT_URL)),
|
|
"/api/access")
|
|
status_request = _request_node(_on_status_completed)
|
|
action_request = _request_node(_on_action_completed)
|
|
purchase_request = _request_node(_on_purchase_status_completed)
|
|
poll_timer = Timer.new()
|
|
poll_timer.wait_time = POLL_INTERVAL_SECONDS
|
|
poll_timer.timeout.connect(_poll_purchase)
|
|
add_child(poll_timer)
|
|
AuthState.auth_changed.connect(_on_auth_changed)
|
|
if AuthState.is_logged_in:
|
|
refresh()
|
|
|
|
|
|
func refresh() -> void:
|
|
if not AuthState.can_send_authenticated_request() or status_request.get_http_client_status() != HTTPClient.STATUS_DISCONNECTED:
|
|
return
|
|
request_token = AuthState.access_token
|
|
status_request.request(api_url, PackedStringArray(["Authorization: Bearer %s" % request_token]))
|
|
|
|
|
|
func redeem_credits() -> void:
|
|
_send_action("redeem", "/redeem-credits", {"operationId": _operation_id("credit-pass")})
|
|
|
|
|
|
func activate_token(token: String) -> void:
|
|
_send_action("activate", "/activate-token", {
|
|
"token": token,
|
|
"operationId": _operation_id("activate-%s" % token)
|
|
})
|
|
|
|
|
|
func reset_qbank() -> void:
|
|
_send_action("reset", "/qbank-reset", {
|
|
"confirmation": "RESET_QBANK",
|
|
"operationId": _operation_id("qbank-reset")
|
|
})
|
|
|
|
|
|
func begin_checkout(sku: String) -> void:
|
|
if OS.has_feature("steam"):
|
|
_send_action("steam_checkout", "/steam-checkouts", {"sku": sku})
|
|
return
|
|
if OS.has_feature("web") and not _prepare_browser_window():
|
|
operation_failed.emit("Checkout needs a popup. Allow popups for this site, then try again.")
|
|
return
|
|
_send_action("checkout", "/web-checkouts", {"sku": sku})
|
|
|
|
|
|
func apply_embedded_status(value: Variant) -> void:
|
|
if typeof(value) != TYPE_DICTIONARY:
|
|
return
|
|
status = value.duplicate(true)
|
|
status_changed.emit(status)
|
|
|
|
|
|
func has_unlimited_access() -> bool:
|
|
return bool(status.get("unlimited", false))
|
|
|
|
|
|
func questions_remaining() -> int:
|
|
return int(status.get("questionsRemaining", 20))
|
|
|
|
|
|
func _send_action(action: String, path: String, payload: Dictionary) -> void:
|
|
if pending_action != "":
|
|
operation_failed.emit("Another access request is still in progress.")
|
|
return
|
|
if not AuthState.can_send_authenticated_request():
|
|
operation_failed.emit("Log in before managing access.")
|
|
return
|
|
pending_action = action
|
|
request_token = AuthState.access_token
|
|
var error := action_request.request(
|
|
"%s%s" % [api_url.rstrip("/"), path],
|
|
PackedStringArray([
|
|
"Content-Type: application/json",
|
|
"Authorization: Bearer %s" % request_token
|
|
]),
|
|
HTTPClient.METHOD_POST,
|
|
JSON.stringify(payload))
|
|
if error != OK:
|
|
pending_action = ""
|
|
operation_failed.emit("The access request could not be started.")
|
|
|
|
|
|
func _on_status_completed(result: int, response_code: int, _headers: PackedStringArray, body: PackedByteArray) -> void:
|
|
if response_code == 401:
|
|
AuthState.handle_unauthorized(request_token)
|
|
if result != HTTPRequest.RESULT_SUCCESS or response_code < 200 or response_code >= 300:
|
|
return
|
|
var parsed: Variant = JSON.parse_string(body.get_string_from_utf8())
|
|
apply_embedded_status(parsed)
|
|
|
|
|
|
func _on_action_completed(result: int, response_code: int, _headers: PackedStringArray, body: PackedByteArray) -> void:
|
|
var action := pending_action
|
|
pending_action = ""
|
|
if response_code == 401:
|
|
AuthState.handle_unauthorized(request_token)
|
|
if result != HTTPRequest.RESULT_SUCCESS or response_code < 200 or response_code >= 300:
|
|
_close_browser_window()
|
|
operation_failed.emit(_failure_message("Access request failed.", response_code, body))
|
|
return
|
|
var parsed: Variant = JSON.parse_string(body.get_string_from_utf8())
|
|
if action == "checkout":
|
|
if typeof(parsed) != TYPE_DICTIONARY:
|
|
_close_browser_window()
|
|
operation_failed.emit("Checkout returned an invalid response.")
|
|
return
|
|
active_purchase_id = str(parsed.get("purchaseId", ""))
|
|
var checkout_url := str(parsed.get("checkoutUrl", ""))
|
|
if active_purchase_id.is_empty() or not checkout_url.begins_with("https://"):
|
|
_close_browser_window()
|
|
operation_failed.emit("Checkout returned an invalid link.")
|
|
return
|
|
_open_checkout_url(checkout_url)
|
|
checkout_started.emit(active_purchase_id, checkout_url)
|
|
poll_count = 0
|
|
poll_timer.start()
|
|
_poll_purchase()
|
|
return
|
|
if typeof(parsed) == TYPE_DICTIONARY:
|
|
apply_embedded_status(parsed)
|
|
operation_succeeded.emit({
|
|
"redeem": "Your 24-hour QBank pass is active.",
|
|
"activate": "Your access token was activated.",
|
|
"reset": "Your QBank has been reset for a new cycle."
|
|
}.get(action, "Access updated."))
|
|
|
|
|
|
func _poll_purchase() -> void:
|
|
if active_purchase_id.is_empty() or not AuthState.can_send_authenticated_request():
|
|
return
|
|
if purchase_request.get_http_client_status() != HTTPClient.STATUS_DISCONNECTED:
|
|
return
|
|
poll_count += 1
|
|
if poll_count > POLL_LIMIT:
|
|
poll_timer.stop()
|
|
return
|
|
request_token = AuthState.access_token
|
|
purchase_request.request(
|
|
"%s/purchases/%s" % [api_url.rstrip("/"), active_purchase_id.uri_encode()],
|
|
PackedStringArray(["Authorization: Bearer %s" % request_token]))
|
|
|
|
|
|
func _on_purchase_status_completed(result: int, response_code: int, _headers: PackedStringArray, body: PackedByteArray) -> void:
|
|
if result != HTTPRequest.RESULT_SUCCESS or response_code < 200 or response_code >= 300:
|
|
return
|
|
var parsed: Variant = JSON.parse_string(body.get_string_from_utf8())
|
|
if typeof(parsed) != TYPE_DICTIONARY:
|
|
return
|
|
match str(parsed.get("status", "")):
|
|
"paid":
|
|
poll_timer.stop()
|
|
_close_browser_window()
|
|
active_purchase_id = ""
|
|
operation_succeeded.emit("Purchase confirmed. Your token is ready to activate.")
|
|
refresh()
|
|
"failed", "expired", "refunded":
|
|
poll_timer.stop()
|
|
_close_browser_window()
|
|
active_purchase_id = ""
|
|
operation_failed.emit("The purchase was not completed.")
|
|
|
|
|
|
func _request_node(callback: Callable) -> HTTPRequest:
|
|
var node := HTTPRequest.new()
|
|
node.timeout = REQUEST_TIMEOUT_SECONDS
|
|
node.request_completed.connect(callback)
|
|
add_child(node)
|
|
return node
|
|
|
|
|
|
func _operation_id(prefix: String) -> String:
|
|
return "%s-%d-%d" % [prefix, Time.get_ticks_usec(), randi()]
|
|
|
|
|
|
func _open_checkout_url(url: String) -> void:
|
|
if OS.has_feature("web"):
|
|
JavaScriptBridge.eval(
|
|
"var ranazeUrl=%s;window.localStorage.setItem('%s',ranazeUrl);if(window.ranazeAccessWindow&&!window.ranazeAccessWindow.closed){window.ranazeAccessWindow.location.replace(ranazeUrl);window.ranazeAccessWindow.focus();}else{window.location.assign(ranazeUrl);}" %
|
|
[JSON.stringify(url), CHECKOUT_STORAGE_KEY], true)
|
|
else:
|
|
OS.shell_open(url)
|
|
|
|
|
|
func _prepare_browser_window() -> bool:
|
|
checkout_popup_opened = bool(JavaScriptBridge.eval(
|
|
"window.ranazeAccessWindow=window.open('about:blank','ranaze_access','popup=yes,width=620,height=760,resizable=yes,scrollbars=yes');window.ranazeAccessWindow!==null;",
|
|
true))
|
|
return checkout_popup_opened
|
|
|
|
|
|
func _close_browser_window() -> void:
|
|
if OS.has_feature("web") and checkout_popup_opened:
|
|
JavaScriptBridge.eval(
|
|
"window.localStorage.removeItem('%s');if(window.ranazeAccessWindow&&!window.ranazeAccessWindow.closed){window.ranazeAccessWindow.close();}window.ranazeAccessWindow=null;window.focus();" %
|
|
CHECKOUT_STORAGE_KEY, true)
|
|
checkout_popup_opened = false
|
|
|
|
|
|
func _failure_message(prefix: String, response_code: int, body: PackedByteArray) -> String:
|
|
var parsed: Variant = JSON.parse_string(body.get_string_from_utf8())
|
|
if typeof(parsed) == TYPE_DICTIONARY:
|
|
var message := str(parsed.get("message", parsed.get("detail", ""))).strip_edges()
|
|
if not message.is_empty():
|
|
return message
|
|
return "%s Status %d." % [prefix, response_code]
|
|
|
|
|
|
func _on_auth_changed() -> void:
|
|
if AuthState.is_logged_in:
|
|
refresh()
|
|
else:
|
|
status = {}
|
|
active_purchase_id = ""
|
|
poll_timer.stop()
|
|
_close_browser_window()
|
|
status_changed.emit(status)
|