205 lines
7.2 KiB
Python
205 lines
7.2 KiB
Python
from django.shortcuts import render
|
|
from django.http import HttpResponse, HttpResponseRedirect
|
|
from django.template import loader
|
|
from json import loads, dumps
|
|
from math import floor
|
|
import requests
|
|
from .forms import ServerAddressForm
|
|
import logging
|
|
|
|
# Create your views here.
|
|
|
|
# Debug and defaults.
|
|
defaults = {
|
|
"listen_address": "http://localhost:51111/",
|
|
}
|
|
logging.basicConfig(encoding="utf-8", level=logging.DEBUG)
|
|
|
|
# API endpoints
|
|
# /overview - {screne, seed, items (int), entrances (int), hints (int), codes (dict of codes in an area and how care they are, can be empty)}
|
|
# /items - {[scene names] ({name (name of item that was received), owner (in multiworld, who received that item)})}
|
|
# /doors - {[scene names] ({scene (name of scene the mapped entrance is in), door (name of entrance it leads to)})}
|
|
# /hints - {[where hint was received] (raw trunic string of hint)}
|
|
|
|
|
|
def session_key(session, key):
|
|
if key not in session.keys():
|
|
session[key] = defaults[key]
|
|
|
|
# TODO: consider serializing user sessions for debugging in the future.
|
|
logging.info(f"Session {key} set to: {session[key]}")
|
|
return session[key]
|
|
|
|
|
|
def index(request):
|
|
listen_address = session_key(request.session, "listen_address")
|
|
|
|
try:
|
|
request_overview_data = requests.get(
|
|
f"{listen_address}overview", timeout=5, verify=True
|
|
).text
|
|
request_items_data = requests.get(
|
|
f"{listen_address}items", timeout=5, verify=True
|
|
).text
|
|
request_doors_data = requests.get(
|
|
f"{listen_address}doors", timeout=5, verify=True
|
|
).text
|
|
request_hints_data = requests.get(
|
|
f"{listen_address}hints", timeout=5, verify=True
|
|
).text
|
|
tracker_overview_data = loads(request_overview_data)
|
|
if "error" in tracker_overview_data.keys():
|
|
raise ValueError
|
|
tracker_items_data = loads(request_items_data)
|
|
tracker_doors_data = loads(request_doors_data)
|
|
tracker_hints_data = loads(request_hints_data)
|
|
except:
|
|
with open("empty_overview.json", "r") as t:
|
|
tracker_overview_data = loads(t.read())
|
|
with open("empty_items.json", "r") as t:
|
|
tracker_items_data = loads(t.read())
|
|
with open("empty_doors.json", "r") as t:
|
|
tracker_doors_data = loads(t.read())
|
|
with open("empty_hints.json", "r") as t:
|
|
tracker_hints_data = loads(t.read())
|
|
with open("tracker/static/tracker/data/holy_cross_codes.json", "r") as t:
|
|
try:
|
|
temp_codes = loads(t.read())
|
|
cross_codes = {
|
|
x: {
|
|
k: l.replace("U", "⬆️")
|
|
.replace("D", "⬇️")
|
|
.replace("L", "⬅️")
|
|
.replace("R", "➡️")
|
|
.strip()
|
|
for k, l in temp_codes[x].items()
|
|
}
|
|
for x in temp_codes.keys()
|
|
}
|
|
except:
|
|
return
|
|
|
|
# Data from the /overview API call
|
|
tracker_current_scene = tracker_overview_data["scene"]
|
|
tracker_seed = tracker_overview_data["seed"]
|
|
tracker_hints_found_total = tracker_overview_data["hints"]
|
|
tracker_current_scene_codes = tracker_overview_data["codes"]
|
|
|
|
# Data from the /doors API call
|
|
tracker_entrances_total = tracker_doors_data["total"]
|
|
tracker_entrances_remaining = tracker_doors_data["remaining"]
|
|
tracker_entrances_mapped_total = tracker_doors_data["found"]
|
|
|
|
# Data from the /items API call
|
|
tracker_checks_total = tracker_items_data["total"]
|
|
tracker_checks_remaining = tracker_items_data["remaining"]
|
|
tracker_checks_cleared_total = tracker_items_data["collected"]
|
|
|
|
active_codes = {}
|
|
for name, value in tracker_current_scene_codes.items():
|
|
logging.debug(value)
|
|
this_scene = tracker_current_scene
|
|
if value["Global"]:
|
|
this_scene = "Global"
|
|
active_codes[name] = {
|
|
"distance": value["Distance"],
|
|
"global": value["Global"],
|
|
"in_range": value["InRange"],
|
|
"code": cross_codes[this_scene][name],
|
|
}
|
|
logging.debug(active_codes)
|
|
|
|
scene_data = {}
|
|
for scene in tracker_doors_data["scenes"].keys():
|
|
scene_data[scene] = {
|
|
"entrances": tracker_doors_data["scenes"][scene],
|
|
"checks": tracker_items_data["scenes"][scene],
|
|
}
|
|
|
|
template = loader.get_template("tracker/index.html")
|
|
server_address_form = ServerAddressForm()
|
|
server_address_form.fields["server_address_form"].initial = listen_address
|
|
logging.debug(format_overview_output(tracker_overview_data))
|
|
context = {
|
|
"server_address": listen_address,
|
|
"debug": {},
|
|
"default_codes": cross_codes["Default"],
|
|
"totals": {
|
|
"Checks": {
|
|
"Undiscovered": tracker_checks_cleared_total,
|
|
"Remaining": tracker_checks_remaining,
|
|
"Total": tracker_checks_total,
|
|
},
|
|
"Entrances": {
|
|
"Undiscovered": tracker_entrances_mapped_total,
|
|
"Remaining": tracker_entrances_remaining,
|
|
"Total": tracker_entrances_total,
|
|
},
|
|
},
|
|
"scenes": scene_data,
|
|
"current_scene": tracker_current_scene,
|
|
"codes": active_codes,
|
|
"server_address_form": server_address_form,
|
|
"hints": tracker_hints_data,
|
|
}
|
|
return HttpResponse(template.render(context, request))
|
|
|
|
|
|
def get_address(request):
|
|
if request.method == "GET":
|
|
return HttpResponse(
|
|
dumps({"listen_address": request.session["listen_address"]}),
|
|
content_type="application/json",
|
|
)
|
|
else:
|
|
return render(request, "tracker/index.html")
|
|
|
|
|
|
def set_address(request):
|
|
if request.method == "POST":
|
|
form = ServerAddressForm(request.POST)
|
|
if form.is_valid():
|
|
request.session["listen_address"] = form.cleaned_data["server_address_form"]
|
|
return HttpResponseRedirect("/")
|
|
else:
|
|
form = ServerAddressForm()
|
|
return render(request, "tracker/index.html", {"server_address_form": form})
|
|
|
|
|
|
def format_overview_output(overview):
|
|
overview_string = "\nReceived Overview Data:\n"
|
|
for key, value in overview.items():
|
|
overview_string += f"\t{key}: "
|
|
if key == "codes":
|
|
overview_string += "\n"
|
|
for code, something in value.items():
|
|
overview_string += f"\t\t{code}: {something['Distance']:.2f}\n"
|
|
else:
|
|
overview_string += f"{value}\n"
|
|
return overview_string
|
|
|
|
|
|
def format_items_output(items):
|
|
items_string = "\nReceived Item Data:\n"
|
|
for key, value in items.items():
|
|
items_string += f"\t{key}:\n"
|
|
for check_key, check_value in value.items():
|
|
items_string += f"\t\t{check_key}: {check_value}\n"
|
|
return items_string
|
|
|
|
|
|
def format_doors_output(doors):
|
|
doors_string = "\nReceived Door Data:\n"
|
|
for key, value in doors.items():
|
|
doors_string += f"\t{key}: "
|
|
for entrance_key, entrance_value in value.items():
|
|
doors_string += f"\t\t{entrance_key}: {entrance_value}\n"
|
|
return doors_string
|
|
|
|
|
|
def format_hints_output(hints):
|
|
hints_string = "\nReceived Hint Data:\n"
|
|
for key, value in hints.items():
|
|
hints_string += f"\t{key}: "
|
|
return hints_string
|