forked from expo/troggle
464 lines
21 KiB
Python
464 lines
21 KiB
Python
import os
|
|
import string
|
|
import re
|
|
import settings
|
|
import urllib.parse
|
|
import subprocess
|
|
from pathlib import Path
|
|
#from PIL import Image, ImageDraw, ImageFont
|
|
|
|
from django import forms
|
|
from django.conf import settings
|
|
from django.urls import reverse
|
|
from django.http import HttpResponse, HttpResponseRedirect, HttpResponseNotFound
|
|
from django.shortcuts import get_object_or_404, render
|
|
from django.core.exceptions import ObjectDoesNotExist, MultipleObjectsReturned
|
|
|
|
import troggle.settings as settings
|
|
from troggle.core.views import expo
|
|
from troggle.core.models.troggle import Expedition, DataIssue
|
|
from troggle.core.models.caves import CaveSlug, Cave, CaveAndEntrance, QM, EntranceSlug, Entrance, Area, SurvexStation, GetCaveLookup
|
|
from troggle.core.forms import CaveForm, CaveAndEntranceFormSet, EntranceForm, EntranceLetterForm
|
|
#from troggle.core.forms import VersionControlCommentForm
|
|
from .login import login_required_if_public
|
|
|
|
'''Manages the complex procedures to assemble a cave description out of the compnoents
|
|
Manages the use of cavern to parse survex files to produce 3d and pos files
|
|
'''
|
|
|
|
def getCaves(cave_id):
|
|
'''Only gets called if a call to getCave() raises a MultipleObjects exception
|
|
|
|
TO DO: search GCavelookup first, which should raise a MultpleObjectsReturned exception if there
|
|
are duplicates'''
|
|
try:
|
|
caves = Cave.objects.filter(kataster_number=cave_id)
|
|
caveset = set(caves)
|
|
|
|
Gcavelookup = GetCaveLookup() # dictionary makes strings to Cave objects
|
|
if cave_id in Gcavelookup:
|
|
caveset.add(Gcavelookup[cave_id])
|
|
return list(caveset)
|
|
except:
|
|
return []
|
|
|
|
|
|
def getCave(cave_id):
|
|
'''Returns a cave object when given a cave name or number. It is used by views including cavehref, ent, and qm.
|
|
|
|
TO DO: search GCavelookup first, which should raise a MultpleObjectsReturned exception if there
|
|
are duplicates'''
|
|
try:
|
|
cave = Cave.objects.get(kataster_number=cave_id)
|
|
return cave
|
|
except Cave.MultipleObjectsReturned as ex:
|
|
raise MultipleObjectsReturned("Duplicate kataster number") from ex # propagate this up
|
|
|
|
except Cave.DoesNotExist as ex:
|
|
Gcavelookup = GetCaveLookup() # dictionary makes strings to Cave objects
|
|
if cave_id in Gcavelookup:
|
|
return Gcavelookup[cave_id]
|
|
else:
|
|
raise ObjectDoesNotExist("No cave found with this identifier in any id field") from ex # propagate this up
|
|
except:
|
|
raise ObjectDoesNotExist("No cave found with this identifier in any id field")
|
|
|
|
def pad5(x):
|
|
return "0" * (5 -len(x.group(0))) + x.group(0)
|
|
def padnumber(x):
|
|
return re.sub("\d+", pad5, x)
|
|
def numericalcmp(x, y):
|
|
return cmp(padnumber(x), padnumber(y))
|
|
|
|
def caveKey(c):
|
|
"""This function goes into a lexicogrpahic sort function, and the values are strings,
|
|
but we want to sort numberically on kataster number before sorting on unofficial number.
|
|
"""
|
|
if not c.kataster_number:
|
|
return "9999." + c.unofficial_number
|
|
else:
|
|
if int(c.kataster_number) >= 100:
|
|
return "99." + c.kataster_number
|
|
if int(c.kataster_number) >= 10:
|
|
return "9." + c.kataster_number
|
|
return c.kataster_number
|
|
|
|
def getnotablecaves():
|
|
notablecaves = []
|
|
for kataster_number in settings.NOTABLECAVESHREFS:
|
|
try:
|
|
cave = Cave.objects.get(kataster_number=kataster_number)
|
|
notablecaves.append(cave)
|
|
except:
|
|
#print(" ! FAILED to get only one cave per kataster_number OR invalid number for: "+kataster_number)
|
|
caves = Cave.objects.all().filter(kataster_number=kataster_number)
|
|
for c in caves:
|
|
#print(c.kataster_number, c.slug())
|
|
if c.slug() != None:
|
|
notablecaves.append(c)
|
|
return notablecaves
|
|
|
|
def caveindex(request):
|
|
caves = Cave.objects.all()
|
|
caves1623 = list(Cave.objects.filter(area__short_name = "1623"))
|
|
caves1626 = list(Cave.objects.filter(area__short_name = "1626"))
|
|
caves1623.sort(key=caveKey)
|
|
caves1626.sort(key=caveKey)
|
|
return render(request,'caveindex.html', {'caves1623': caves1623, 'caves1626': caves1626, 'notablecaves':getnotablecaves(), 'cavepage': True})
|
|
|
|
def cave3d(request, cave_id=''):
|
|
'''This is used to create a download url in templates/cave.html if anyone wants to download the .3d file
|
|
The caller template tries kataster first, then unofficial_number if that kataster number does not exist
|
|
but only if Cave.survex_file is non-empty
|
|
|
|
But the template file cave.html has its own ideas about the name of the file and thus the href. Ouch.
|
|
/cave/3d/<cave_id>
|
|
'''
|
|
try:
|
|
cave = getCave(cave_id)
|
|
except ObjectDoesNotExist:
|
|
return HttpResponseNotFound
|
|
except Cave.MultipleObjectsReturned:
|
|
# But only one might have survex data? So scan and return the first that works.
|
|
caves = getCaves(cave_id)
|
|
for c in caves:
|
|
if c.survex_file:
|
|
# exists, but may not be a valid file path to a valid .svx file in the Loser repo
|
|
return file3d(request, c, c.slug)
|
|
else:
|
|
return file3d(request, cave, cave_id)
|
|
|
|
def file3d(request, cave, cave_id):
|
|
'''Produces a .3d file directly for download.
|
|
survex_file should be in valid path format 'caves-1623/264/264.svx' but it might be mis-entered as simply '2012-ns-10.svx'
|
|
|
|
Also the cave.survex_file may well not match the cave description path:
|
|
e.g. it might be to the whole system 'smk-system.svx' instead of just for the specific cave.
|
|
|
|
- If the expected .3d file corresponding to cave.survex_file is present, return it.
|
|
- If the cave.survex_file exists, generate the 3d file, cache it and return it
|
|
- Use the cave_id to guess what the 3d file might be and, if in the cache, return it
|
|
- Use the cave_id to guess what the .svx file might be and generate the .3d file and return it
|
|
- (Use the incomplete cave.survex_file and a guess at the missing directories to guess the real .svx file location ?)
|
|
'''
|
|
def runcavern(survexpath):
|
|
#print(" - Regenerating cavern .log and .3d for '{}'".format(survexpath))
|
|
if not survexpath.is_file():
|
|
#print(" - - Regeneration ABORT\n - - from '{}'".format(survexpath))
|
|
pass
|
|
try:
|
|
completed_process = subprocess.run([settings.CAVERN, "--log", "--output={}".format(settings.THREEDCACHEDIR), "{}".format(survexpath)])
|
|
except OSError as ex:
|
|
# propagate this to caller.
|
|
raise OSError(completed_process.stdout) from ex
|
|
|
|
op3d = (Path(settings.THREEDCACHEDIR) / Path(survexpath).name).with_suffix('.3d')
|
|
op3dlog = Path(op3d.with_suffix('.log'))
|
|
|
|
if not op3d.is_file():
|
|
print(" - - Regeneration FAILED\n - - from '{}'\n - - to '{}'".format(survexpath, op3d))
|
|
print(" - - Regeneration stdout: ", completed_process.stdout)
|
|
print(" - - Regeneration cavern log output: ", op3dlog.read_text())
|
|
|
|
|
|
def return3d(threedpath):
|
|
if threedpath.is_file():
|
|
response = HttpResponse(content=open(threedpath, 'rb'), content_type='application/3d')
|
|
response['Content-Disposition'] = 'attachment; filename={}'.format(threedpath.name)
|
|
return response
|
|
else:
|
|
message = '<h1>Path provided does not correspond to any actual 3d file.</h1><p>path: "{}"'.format(threedpath)
|
|
#print(message)
|
|
return HttpResponseNotFound(message)
|
|
|
|
survexname = Path(cave.survex_file).name # removes directories
|
|
survexpath = Path(settings.SURVEX_DATA, cave.survex_file)
|
|
threedname = Path(survexname).with_suffix('.3d') # removes .svx, replaces with .3d
|
|
threedpath = Path(settings.THREEDCACHEDIR, threedname)
|
|
threedcachedir = Path(settings.THREEDCACHEDIR)
|
|
|
|
# These if statements need refactoring more cleanly
|
|
if cave.survex_file:
|
|
#print(" - cave.survex_file '{}'".format(cave.survex_file))
|
|
if threedpath.is_file():
|
|
#print(" - threedpath '{}'".format(threedpath))
|
|
# possible error here as several .svx files of same names in different directories will overwrite in /3d/
|
|
if survexpath.is_file():
|
|
if os.path.getmtime(survexpath) > os.path.getmtime(threedpath):
|
|
runcavern(survexpath)
|
|
return return3d(threedpath)
|
|
else:
|
|
#print(" - - survexpath '{}'".format(survexpath))
|
|
if survexpath.is_file():
|
|
#print(" - - - survexpath '{}'".format(survexpath))
|
|
runcavern(survexpath)
|
|
return return3d(threedpath)
|
|
|
|
# Get here if cave.survex_file was set but did not correspond to a valid svx file
|
|
if survexpath.is_file():
|
|
# a file, but invalid format
|
|
message='<h1>File is not valid .svx format.</h1><p>Could not generate 3d file from "{}"'.format(survexpath)
|
|
else:
|
|
# we could try to guess that 'caves-1623/' is missing,... nah.
|
|
message = '<h1>Path provided does not correspond to any actual file.</h1><p>path: "{}"'.format(survexpath)
|
|
|
|
return HttpResponseNotFound(message)
|
|
|
|
|
|
def rendercave(request, cave, slug, cave_id=''):
|
|
'''Gets the data and files ready and then triggers Django to render the template.
|
|
The resulting html contains urls which are dispatched independently, e.g. the 'download' link
|
|
'''
|
|
#print(" ! rendercave:'{}' slug:'{}' cave_id:'{}'".format(cave, slug, cave_id))
|
|
|
|
if cave.non_public and settings.PUBLIC_SITE and not request.user.is_authenticated:
|
|
return render(request, 'nonpublic.html', {'instance': cave, 'cavepage': True, 'cave_id': cave_id})
|
|
else:
|
|
svxstem = Path(cave.survex_file).parent / Path(cave.survex_file).stem
|
|
svx3d = Path(cave.survex_file).stem
|
|
|
|
# NOTE the template itself loads the 3d file using javascript before it loads anything else.
|
|
# Django cannot see what this javascript is doing, so we need to ensure that the 3d file exists first.
|
|
# run this just for the side-effect of generating the 3d file? Nope, crashes.
|
|
# TO DO - restructure this so that the regeneration is callable from here.
|
|
#discard_response = cave3d(request, cave_id=cave_id)
|
|
templatefile = 'cave.html'
|
|
if request.user.is_authenticated:
|
|
editable = True
|
|
else:
|
|
editable = False
|
|
#print(f" ! rendercave:'{cave}' using template '{templatefile}' svxstem:'{svxstem}' caveid:'{cave_id}' svx3d:'{svx3d}'")
|
|
if not cave_id:
|
|
cave_id = slug # cave.unofficial_number
|
|
try:
|
|
r = render(request,templatefile, {'cave_editable': editable, 'settings': settings, 'cave': cave, 'cavepage': True,
|
|
'cave_id': cave_id, 'svxstem': svxstem, 'svx3d':svx3d})
|
|
return r
|
|
except:
|
|
raise
|
|
return render(request,'errors/generic.html', {'cave_editable': editable, 'settings': settings, 'cave': cave, 'cavepage': True,
|
|
'cave_id': cave_id, 'svxstem': svxstem, 'svx3d':svx3d})
|
|
|
|
|
|
def cavepage(request, karea, subpath):
|
|
'''Displays a cave description page
|
|
accessed by kataster area number specifically
|
|
|
|
There are A LOT OF URLS to e.g. /1623/161/l/rl89a.htm which are IMAGES and html files
|
|
in cave descriptions. These need to be handled HERE
|
|
'''
|
|
path = karea + subpath
|
|
#print(" ! cavepage:'{}' kataster area:'{}' rest of path:'{}'".format(path, karea, subpath))
|
|
|
|
try:
|
|
cave = Cave.objects.get(url = path) # ideally this will be unique
|
|
return rendercave(request, cave, cave.slug())
|
|
|
|
except Cave.DoesNotExist:
|
|
# probably a link to text or an image e.g. 1623/161/l/rl89a.htm i.e. an expoweb page
|
|
return expo.expopage(request, path)
|
|
except Cave.MultipleObjectsReturned:
|
|
caves = Cave.objects.filter(url = path)
|
|
# we should have a -several variant for the cave pages, not just the svxcaves:
|
|
return render(request, 'svxcaveseveral.html', {'settings': settings, "caves":caves })
|
|
except:
|
|
raise
|
|
return render(request, 'pagenotfound.html', {'path': path}) # it does not seem possible to set the status_code to '404'
|
|
|
|
def cave(request, cave_id='', offical_name=''):
|
|
'''Displays a cave description page
|
|
accesssed by a fairly random id which might be anything
|
|
'''
|
|
try:
|
|
cave=getCave(cave_id)
|
|
except MultipleObjectsReturned:
|
|
caves = Cave.objects.filter(kataster_number=cave_id)
|
|
return render(request, 'svxcaveseveral.html', {'settings': settings, "caves":caves }) # not the right template, needs a specific one
|
|
except ObjectDoesNotExist:
|
|
return render(request, 'svxcavesingle404.html', {'settings': settings, "cave":cave_id })
|
|
except:
|
|
return render(request, 'svxcavesingle404.html', {'settings': settings })
|
|
|
|
return rendercave(request, cave, cave.slug(), cave_id=cave_id)
|
|
|
|
def caveEntrance(request, slug):
|
|
cave = Cave.objects.get(caveslug__slug = slug)
|
|
if cave.non_public and settings.PUBLIC_SITE and not request.user.is_authenticated:
|
|
return render(request,'nonpublic.html', {'instance': cave})
|
|
else:
|
|
return render(request,'cave_entrances.html', {'cave': cave})
|
|
|
|
def caveDescription(request, slug):
|
|
cave = Cave.objects.get(caveslug__slug = slug)
|
|
if cave.non_public and settings.PUBLIC_SITE and not request.user.is_authenticated:
|
|
return render(request,'nonpublic.html', {'instance': cave})
|
|
else:
|
|
return render(request,'cave_uground_description.html', {'cave': cave})
|
|
|
|
def caveQMs(request, slug):
|
|
cave = Cave.objects.get(caveslug__slug = slug)
|
|
if cave.non_public and settings.PUBLIC_SITE and not request.user.is_authenticated:
|
|
return render(request,'nonpublic.html', {'instance': cave})
|
|
else:
|
|
return render(request,'cave_qms.html', {'cave': cave})
|
|
|
|
@login_required_if_public
|
|
def edit_cave(request, slug=None):
|
|
'''This is the form that edits all the cave data and writes out an XML file in the :expoweb: repo folder
|
|
The format for the file being saved is in templates/dataformat/cave.xml
|
|
|
|
It does save the data into into the database directly, not by parsing the file.
|
|
'''
|
|
message = ""
|
|
if slug is not None:
|
|
cave = Cave.objects.get(caveslug__slug = slug)
|
|
else:
|
|
cave = Cave()
|
|
if request.POST:
|
|
form = CaveForm(request.POST, instance=cave)
|
|
ceFormSet = CaveAndEntranceFormSet(request.POST)
|
|
#versionControlForm = VersionControlCommentForm(request.POST)
|
|
if form.is_valid() and ceFormSet.is_valid():
|
|
#print(f'! POST is valid. {cave}')
|
|
cave = form.save(commit = False)
|
|
if slug is None:
|
|
for a in form.cleaned_data["area"]:
|
|
if a.kat_area():
|
|
myArea = a.kat_area()
|
|
if form.cleaned_data["kataster_number"]:
|
|
myslug = "%s-%s" % (myArea, form.cleaned_data["kataster_number"])
|
|
else:
|
|
myslug = "%s-%s" % (myArea, form.cleaned_data["unofficial_number"])
|
|
else:
|
|
myslug = slug
|
|
# Converting a PENDING cave to a real cave by saving this form
|
|
myslug = myslug.replace('-PENDING-', '-')
|
|
cave.filename = myslug + ".html"
|
|
cave.save()
|
|
form.save_m2m()
|
|
if slug is None:
|
|
cs = CaveSlug(cave = cave, slug = myslug, primary = True)
|
|
cs.save()
|
|
ceinsts = ceFormSet.save(commit=False)
|
|
for ceinst in ceinsts:
|
|
ceinst.cave = cave
|
|
ceinst.save()
|
|
cave.writeDataFile()
|
|
return HttpResponseRedirect("/" + cave.url)
|
|
else:
|
|
message = f'! POST data is INVALID {cave}'
|
|
print(message)
|
|
else:
|
|
form = CaveForm(instance=cave)
|
|
ceFormSet = CaveAndEntranceFormSet(queryset=cave.caveandentrance_set.all())
|
|
#versionControlForm = VersionControlCommentForm()
|
|
|
|
return render(request,
|
|
'editcave.html',
|
|
{'form': form, 'cave': cave, 'message': message,
|
|
'caveAndEntranceFormSet': ceFormSet,
|
|
#'versionControlForm': versionControlForm
|
|
})
|
|
|
|
@login_required_if_public
|
|
def edit_entrance(request, caveslug=None, slug=None):
|
|
'''This is the form that edits the entrance data for a single entrance and writes out
|
|
an XML file in the :expoweb: repo folder
|
|
The format for the file being saved is in templates/dataformat/entrance.xml
|
|
|
|
It does save the data into into the database directly, not by parsing the file.
|
|
'''
|
|
message = ""
|
|
if caveslug is not None:
|
|
cave = Cave.objects.get(caveslug__slug = caveslug)
|
|
else:
|
|
cave = Cave()
|
|
if slug is not None:
|
|
entrance = Entrance.objects.get(entranceslug__slug = slug)
|
|
else:
|
|
entrance = Entrance()
|
|
if request.POST:
|
|
form = EntranceForm(request.POST, instance = entrance)
|
|
#versionControlForm = VersionControlCommentForm(request.POST)
|
|
if slug is None:
|
|
entletter = EntranceLetterForm(request.POST)
|
|
else:
|
|
entletter = None
|
|
if form.is_valid() and (slug is not None or entletter.is_valid()):
|
|
entrance = form.save(commit = False)
|
|
if slug is None:
|
|
if entletter.cleaned_data["entrance_letter"]:
|
|
slugname = cave.slug() + entletter.cleaned_data["entrance_letter"]
|
|
else:
|
|
slugname = cave.slug()
|
|
entrance.cached_primary_slug = slugname
|
|
entrance.filename = slugname + ".html"
|
|
entrance.save()
|
|
if slug is None:
|
|
es = EntranceSlug(entrance = entrance, slug = slugname, primary = True)
|
|
es.save()
|
|
el = entletter.save(commit = False)
|
|
el.cave = cave
|
|
el.entrance = entrance
|
|
el.save()
|
|
entrance.writeDataFile()
|
|
return HttpResponseRedirect("/" + cave.url)
|
|
else:
|
|
message = f'! POST data is INVALID {cave}'
|
|
print(message)
|
|
else:
|
|
form = EntranceForm(instance = entrance)
|
|
#versionControlForm = VersionControlCommentForm()
|
|
if slug is None:
|
|
entletter = EntranceLetterForm(request.POST)
|
|
else:
|
|
entletter = None
|
|
return render(request,
|
|
'editentrance.html',
|
|
{'form': form, 'cave': cave, 'message': message,
|
|
#'versionControlForm': versionControlForm,
|
|
'entletter': entletter
|
|
})
|
|
|
|
def qm(request,cave_id,qm_id,year,grade=None):
|
|
year=int(year)
|
|
try:
|
|
qm=getCave(cave_id).get_QMs().get(number=qm_id,found_by__date__year=year)
|
|
return render(request,'qm.html',locals())
|
|
except Cave.MultipleObjectsReturned: # entirely the wrong action, REPLACE with the right display
|
|
caves = Cave.objects.filter(kataster_number=cave_id)
|
|
return render(request, 'svxcaveseveral.html', {'settings': settings, "caves":caves })
|
|
|
|
except QM.DoesNotExist:
|
|
url=urllib.parse.urljoin(settings.URL_ROOT, r'/admin/core/qm/add/'+'?'+ r'number=' + qm_id)
|
|
if grade:
|
|
url += r'&grade=' + grade
|
|
return HttpResponseRedirect(url)
|
|
|
|
def ent(request, cave_id, ent_letter):
|
|
cave = Cave.objects.filter(kataster_number = cave_id)[0]
|
|
cave_and_ent = CaveAndEntrance.objects.filter(cave = cave).filter(entrance_letter = ent_letter)[0]
|
|
return render(request,'entrance.html', {'cave': cave,
|
|
'entrance': cave_and_ent.entrance,
|
|
'letter': cave_and_ent.entrance_letter,})
|
|
|
|
def entranceSlug(request, slug):
|
|
entrance = Entrance.objects.get(entranceslug__slug = slug)
|
|
if entrance.non_public and not request.user.is_authenticated:
|
|
return render(request,'nonpublic.html', {'instance': entrance})
|
|
else:
|
|
return render(request,'entranceslug.html', {'entrance': entrance})
|
|
|
|
def surveyindex(request):
|
|
surveys=Survey.objects.all()
|
|
expeditions=Expedition.objects.order_by("-year")
|
|
return render(request,'survey.html',locals())
|
|
|
|
def get_entrances(request, caveslug):
|
|
cave = Cave.objects.get(caveslug__slug = caveslug)
|
|
return render(request,'options.html', {"items": [(e.entrance.slug(), e.entrance.slug()) for e in cave.entrances()]})
|
|
|
|
def get_qms(request, caveslug):
|
|
cave = Cave.objects.get(caveslug__slug = caveslug)
|
|
return render(request,'options.html', {"items": [(e.entrance.slug(), e.entrance.slug()) for e in cave.entrances()]})
|