mirror of
https://expo.survex.com/repositories/troggle/.git
synced 2024-11-25 08:41:51 +00:00
358 lines
13 KiB
Python
358 lines
13 KiB
Python
from collections import OrderedDict
|
|
from math import sqrt
|
|
from pathlib import Path
|
|
|
|
from django.shortcuts import render
|
|
|
|
import troggle.settings as settings
|
|
from troggle.core.models.caves import Cave, Entrance
|
|
from troggle.core.models.logbooks import LogbookEntry
|
|
from troggle.core.models.survex import SurvexStation, SurvexPersonRole
|
|
from troggle.core.models.troggle import DataIssue, Expedition, Person, PersonExpedition
|
|
from troggle.core.models.wallets import Wallet
|
|
from troggle.parsers.people import GetPersonExpeditionNameLookup, foreign_friends
|
|
from troggle.core.utils import current_expo
|
|
|
|
# from django.views.generic.list import ListView
|
|
"""Very simple report pages summarizing data about the whole set of expeditions and of
|
|
the status of data inconsistencies
|
|
"""
|
|
|
|
def svxfilewild(request, year=None):
|
|
"""Looks for survexfiles which do not have an associated
|
|
wallet, per year
|
|
"""
|
|
legsbyexpo = []
|
|
addupsurvexlength = 0.0
|
|
addupsurvexlegs = 0
|
|
|
|
if not year:
|
|
expos = Expedition.objects.all()
|
|
else:
|
|
expos = Expedition.objects.filter(year=year)
|
|
|
|
for expedition in expos:
|
|
survexblocks = expedition.survexblock_set.all()
|
|
legsyear = 0
|
|
survexleglength = 0.0
|
|
for survexblock in survexblocks:
|
|
survexleglength += survexblock.legslength
|
|
legsyear += int(survexblock.legsall)
|
|
addupsurvexlength += survexleglength
|
|
addupsurvexlegs += legsyear
|
|
legsbyexpo.append((expedition, {"nsurvexlegs": legsyear, "survexleglength": survexleglength}))
|
|
legsbyexpo.reverse()
|
|
|
|
svxwild = []
|
|
wildlength = 0.0
|
|
for expedition in expos:
|
|
survexblocks = expedition.survexblock_set.all()
|
|
for sb in survexblocks:
|
|
# print(f"{sb=}")
|
|
if sb.scanswallet == None:
|
|
if sb.name != "rootblock":
|
|
svxwild.append(sb)
|
|
print(f" WILD {sb.survexfile} {sb.date}")
|
|
wildlength += sb.legslength
|
|
sb.year = f"{expedition}"
|
|
people = SurvexPersonRole.objects.filter(survexblock=sb)
|
|
team = []
|
|
for p in people:
|
|
team.append(p.personname)
|
|
sb.team = team
|
|
walletslength = 0.0
|
|
if year:
|
|
wallets = Wallet.objects.filter(walletyear__year=year)
|
|
for w in wallets:
|
|
for sb in w.survexblock_set.all():
|
|
walletslength += sb.legslength
|
|
if not year:
|
|
year = current_expo()
|
|
return render(request, "survexfilewild.html",
|
|
{"addupsurvexlength": addupsurvexlength / 1000,
|
|
"legsbyexpo": legsbyexpo,
|
|
"nsurvexlegs": addupsurvexlegs,
|
|
"walletslength": walletslength,
|
|
"wildlength": wildlength,
|
|
"year":year,
|
|
"svxwild": svxwild}
|
|
)
|
|
|
|
def therionissues(request):
|
|
"""Page displaying contents of a file produced during data import"""
|
|
logname = "therionrefs.log"
|
|
logpath = Path(settings.PYTHON_PATH, logname)
|
|
therionlog = []
|
|
newlog = []
|
|
|
|
if Path(logpath).is_file:
|
|
try:
|
|
with open(logpath, "r") as f:
|
|
therionlog = f.readlines()
|
|
print(f"{logpath} has {len(therionlog)} entries")
|
|
except:
|
|
msg = f"{logpath} EXCEPTION opening or reading therion logfile. Run a full reset."
|
|
print(msg)
|
|
return render(request, "therionreport.html", {"therionlog": newlog})
|
|
else:
|
|
print(f"{logpath} NOT FOUND: {len(therionlog)} entries")
|
|
|
|
for line in therionlog:
|
|
line = line.replace("! Un-parsed image filename:", "")
|
|
newlog.append(line)
|
|
return render(request, "therionreport.html", {"therionlog": newlog, "year": current_expo()})
|
|
|
|
|
|
def surveximport(request):
|
|
"""Page displaying contents of a file produced during data import"""
|
|
logname = "svxlinear.log"
|
|
logpath = Path(settings.PYTHON_PATH, logname)
|
|
|
|
if Path(logpath).is_file:
|
|
with open(logpath, "r") as f:
|
|
contents = f.read()
|
|
else:
|
|
print(f"{logpath} NOT FOUND {len(contents)}")
|
|
return render(request, "survexreport.html", {"log": contents, "year": current_expo()})
|
|
|
|
|
|
def survexdebug(request):
|
|
"""Page displaying contents of a file produced during data import"""
|
|
logname = "svxblks.log"
|
|
logpath = Path(settings.PYTHON_PATH, logname)
|
|
|
|
if Path(logpath).is_file:
|
|
with open(logpath, "r") as f:
|
|
contents = f.read()
|
|
else:
|
|
print(f"{logpath} NOT FOUND {len(contents)}")
|
|
return render(request, "survexdebug.html", {"log": contents, "year": current_expo()})
|
|
|
|
|
|
def pathsreport(request):
|
|
"""The CONSTANTs declared in the settings and localsettings and how they have
|
|
been evaluated for this specific installation - live"""
|
|
pathsdict = OrderedDict()
|
|
try:
|
|
pathsdict = {
|
|
# "BOGUS" : str( settings.BOGUS),
|
|
"JSLIB_URL": str(settings.JSLIB_URL),
|
|
"JSLIB_ROOT": str(settings.JSLIB_ROOT),
|
|
# "CSSLIB_URL" : str( settings.CSSLIB_URL),
|
|
"CAVEDESCRIPTIONS": str(settings.CAVEDESCRIPTIONS),
|
|
"DIR_ROOT": str(settings.DIR_ROOT),
|
|
"ENTRANCEDESCRIPTIONS": str(settings.ENTRANCEDESCRIPTIONS),
|
|
"EXPOUSER_EMAIL": str(settings.EXPOUSER_EMAIL),
|
|
"EXPOUSERPASS": str("<redacted>"),
|
|
"EXPOUSER": str(settings.EXPOUSER),
|
|
"EXPOWEB": str(settings.EXPOWEB),
|
|
# "EXPOWEB_URL": str(settings.EXPOWEB_URL),
|
|
# "FILES" : str( settings.FILES),
|
|
"LIBDIR": str(settings.LIBDIR),
|
|
"LOGFILE": str(settings.LOGFILE),
|
|
"LOGIN_REDIRECT_URL": str(settings.LOGIN_REDIRECT_URL),
|
|
"MEDIA_ROOT": str(settings.MEDIA_ROOT),
|
|
"MEDIA_URL": str(settings.MEDIA_URL),
|
|
"PHOTOS_URL": str(settings.PHOTOS_URL),
|
|
"PHOTOS_ROOT": str(settings.PHOTOS_ROOT),
|
|
"PYTHON_PATH": str(settings.PYTHON_PATH),
|
|
"REPOS_ROOT_PATH": str(settings.REPOS_ROOT_PATH),
|
|
"ROOT_URLCONF": str(settings.ROOT_URLCONF),
|
|
"STATIC_URL": str(settings.STATIC_URL),
|
|
"SURVEX_DATA": str(settings.SURVEX_DATA),
|
|
"SCANS_ROOT": str(settings.SCANS_ROOT),
|
|
# "SURVEYS" : str( settings.SURVEYS),
|
|
# "SCANS_URL" : str( settings.SCANS_URL),
|
|
"SURVEXPORT": str(settings.SURVEXPORT),
|
|
"DRAWINGS_DATA": str(settings.DRAWINGS_DATA),
|
|
"URL_ROOT": str(settings.URL_ROOT),
|
|
}
|
|
except:
|
|
pathsdict["! EXCEPTION !"] = "missing or exta string constant in troggle/settings"
|
|
|
|
pathstype = OrderedDict()
|
|
try:
|
|
pathstype = {
|
|
# "BOGUS" : type(settings.BOGUS),
|
|
"JSLIB_URL": type(settings.JSLIB_URL),
|
|
"JSLIB_ROOT": type(settings.JSLIB_ROOT),
|
|
# "CSSLIB_URL" : type(settings.CSSLIB_URL),
|
|
"CAVEDESCRIPTIONS": type(settings.CAVEDESCRIPTIONS),
|
|
"DIR_ROOT": type(settings.DIR_ROOT),
|
|
"ENTRANCEDESCRIPTIONS": type(settings.ENTRANCEDESCRIPTIONS),
|
|
"EXPOUSER_EMAIL": type(settings.EXPOUSER_EMAIL),
|
|
"EXPOUSERPASS": type(settings.EXPOUSERPASS),
|
|
"EXPOUSER": type(settings.EXPOUSER),
|
|
"EXPOWEB": type(settings.EXPOWEB),
|
|
# "EXPOWEB_URL": type(settings.EXPOWEB_URL),
|
|
# "FILES" : type(settings.FILES),
|
|
"LIBDIR": type(settings.LIBDIR),
|
|
"LOGFILE": type(settings.LOGFILE),
|
|
"LOGIN_REDIRECT_URL": type(settings.LOGIN_REDIRECT_URL),
|
|
"MEDIA_ROOT": type(settings.MEDIA_ROOT),
|
|
"MEDIA_URL": type(settings.MEDIA_URL),
|
|
"PHOTOS_ROOT": type(settings.PHOTOS_ROOT),
|
|
"PHOTOS_URL": type(settings.PHOTOS_URL),
|
|
"PYTHON_PATH": type(settings.PYTHON_PATH),
|
|
"REPOS_ROOT_PATH": type(settings.REPOS_ROOT_PATH),
|
|
"ROOT_URLCONF": type(settings.ROOT_URLCONF),
|
|
"STATIC_URL": type(settings.STATIC_URL),
|
|
"SURVEX_DATA": type(settings.SURVEX_DATA),
|
|
"SCANS_ROOT": type(settings.SCANS_ROOT),
|
|
# "SURVEYS" : type(settings.SURVEYS),
|
|
# "SCANS_URL" : type(settings.SCANS_URL),
|
|
"SURVEXPORT": type(settings.SURVEXPORT),
|
|
"DRAWINGS_DATA": type(settings.DRAWINGS_DATA),
|
|
"URL_ROOT": type(settings.URL_ROOT),
|
|
}
|
|
except:
|
|
pathstype["! EXCEPTION !"] = "missing or exta string constant in troggle/settings"
|
|
raise
|
|
|
|
# settings are unique by paths are not
|
|
ncodes = len(pathsdict)
|
|
bycodeslist = sorted(pathsdict.items()) # a list of tuples
|
|
bycodeslist2 = []
|
|
|
|
for k, p in bycodeslist:
|
|
bycodeslist2.append((k, p, str(pathstype[k])))
|
|
|
|
bypaths = sorted(pathsdict.values()) # a list
|
|
bypathslist = []
|
|
|
|
for p in bypaths:
|
|
for k in pathsdict.keys():
|
|
if pathsdict[k] == p:
|
|
bypathslist.append((p, k, str(pathstype[k])))
|
|
del pathsdict[k]
|
|
break
|
|
|
|
return render(
|
|
request,
|
|
"pathsreport.html",
|
|
{"pathsdict": pathsdict, "bycodeslist": bycodeslist2, "bypathslist": bypathslist, "ncodes": ncodes, "year": current_expo()},
|
|
)
|
|
|
|
|
|
def stats(request):
|
|
"""Calculates number of survey blocks, the number of survey legs and the survey length for each year.
|
|
This is only underground survey legs, but includes ARGE as well as Expo survex files.
|
|
"""
|
|
statsDict = {}
|
|
statsDict["expoCount"] = f"{Expedition.objects.count():,}"
|
|
statsDict["caveCount"] = f"{Cave.objects.count():,}"
|
|
statsDict["personCount"] = f"{Person.objects.count():,}"
|
|
statsDict["logbookEntryCount"] = f"{LogbookEntry.objects.count():,}"
|
|
|
|
legsbyexpo = []
|
|
addupsurvexlength = 0.0
|
|
addupsurvexlegs = 0
|
|
for expedition in Expedition.objects.all():
|
|
survexblocks = expedition.survexblock_set.all()
|
|
legsyear = 0
|
|
survexleglength = 0.0
|
|
for survexblock in survexblocks:
|
|
survexleglength += survexblock.legslength
|
|
legsyear += int(survexblock.legsall)
|
|
addupsurvexlength += survexleglength
|
|
addupsurvexlegs += legsyear
|
|
legsbyexpo.append((expedition, {"nsurvexlegs": legsyear, "survexleglength": survexleglength}))
|
|
legsbyexpo.reverse()
|
|
|
|
renderDict = {
|
|
**statsDict,
|
|
**{"addupsurvexlength": addupsurvexlength / 1000, "legsbyexpo": legsbyexpo, "nsurvexlegs": addupsurvexlegs, "year": current_expo()},
|
|
} # new syntax
|
|
return render(request, "statistics.html", renderDict)
|
|
|
|
|
|
def dataissues(request):
|
|
"""Each issue has a parser, a message and a url linking to the offending object after loading
|
|
|
|
This page happens to be the first one looked for, so if the server is offline, this is
|
|
where the error happens."""
|
|
|
|
def myFunc(di):
|
|
return di.parser.lower() + di.message.lower()
|
|
|
|
dilist = list(DataIssue.objects.all())
|
|
dilist.sort(key=myFunc)
|
|
|
|
try:
|
|
return render(request, "dataissues.html", {"didict": dilist, "year": current_expo()})
|
|
except:
|
|
message = f'! - Server not online - please wait 5 minutes for database rebuild'
|
|
print(message)
|
|
return render(request, "errors/generic.html", {"message": message})
|
|
|
|
|
|
def stations(request):
|
|
"""report each Northing/Easting pair wherever recorded"""
|
|
ents = set()
|
|
gpsents = set()
|
|
|
|
def add_stations(e):
|
|
try:
|
|
ts = e.tag_station
|
|
if ts:
|
|
e.tag_ts = SurvexStation.objects.get(name=ts)
|
|
#print(f"{e} {e.tag_ts} {e.tag_ts.lat()} {e.tag_ts.long()}")
|
|
|
|
|
|
os = e.other_station
|
|
if os:
|
|
e.tag_os = SurvexStation.objects.get(name=os)
|
|
#print(f"{e} {e.tag_os} {e.tag_os.lat()} {e.tag_os.long()}")
|
|
|
|
except:
|
|
e.tag_ss = None
|
|
e.tag_es = None
|
|
e.tag_os = None
|
|
# print(f"exception for {e}")
|
|
|
|
entrances = Entrance.objects.all()
|
|
for e in entrances:
|
|
if e.other_station:
|
|
ents.add(e)
|
|
add_stations(e)
|
|
|
|
for e in entrances:
|
|
if e.lat_wgs84 or e.long_wgs84:
|
|
gpsents.add(e)
|
|
add_stations(e)
|
|
|
|
|
|
stations = SurvexStation.objects.all() # NB these are NOT all the stations in troggle_import_root.pos
|
|
|
|
return render(request, "stations.html", {"ents": ents, "gpsents": gpsents, "stations": stations, "year": current_expo()})
|
|
|
|
|
|
def aliases(request, year):
|
|
"""Page which displays a list of all the person aliases in a specific year"""
|
|
|
|
if not year:
|
|
year = 1998
|
|
expo = Expedition.objects.filter(year=year)[0] # returns a set, even though we know there is only one
|
|
personexpeditions = PersonExpedition.objects.filter(expedition=expo)
|
|
persons = list(Person.objects.all().order_by("last_name"))
|
|
|
|
aliases = GetPersonExpeditionNameLookup(expo)
|
|
|
|
aliasdict = {}
|
|
for i in sorted(aliases):
|
|
aliasdict[i] = aliases[i]
|
|
invert = {}
|
|
|
|
return render(
|
|
request,
|
|
"aliases.html",
|
|
{
|
|
"year": year,
|
|
"aliasdict": aliasdict,
|
|
"foreign_friends": foreign_friends,
|
|
"invert": invert,
|
|
"personexpeditions": personexpeditions,
|
|
"persons": persons,
|
|
},
|
|
)
|