tunic-tracker-redux/tunictracker/tracker/views.py

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