forked from expo/troggle
242 lines
11 KiB
Python
242 lines
11 KiB
Python
import datetime
|
|
import os.path
|
|
import re
|
|
|
|
import django.db.models
|
|
from django.db.models import Min, Max
|
|
from django.urls import reverse
|
|
from django.http import HttpResponse, HttpResponseRedirect
|
|
from django.shortcuts import render
|
|
from django.template import Context, loader
|
|
from django.template.defaultfilters import slugify
|
|
from django.utils import timezone
|
|
from django.views.generic.list import ListView
|
|
|
|
from troggle.core.models.troggle import Expedition, Person, PersonExpedition
|
|
from troggle.core.utils import TROG
|
|
from troggle.core.models.caves import LogbookEntry, PersonTrip
|
|
from troggle.core.models.survex import SurvexBlock, Wallet
|
|
from .auth import login_required_if_public
|
|
from troggle.parsers.logbooks import LoadLogbookForExpedition
|
|
from troggle.parsers.people import GetPersonExpeditionNameLookup
|
|
|
|
import troggle.settings as settings
|
|
|
|
'''These views are for logbook items when they appear in an 'expedition' page
|
|
and for persons: their individual pages and their perseonexpedition pages.
|
|
|
|
It uses the global object TROG to hold some cached pages.
|
|
'''
|
|
|
|
todo = '''Fix the get_person_chronology() display bug.
|
|
'''
|
|
|
|
def notablepersons(request):
|
|
def notabilitykey(person):
|
|
return person.notability()
|
|
|
|
persons = Person.objects.all()
|
|
# From what I can tell, "persons" seems to be the table rows, while "pcols" is the table columns. - AC 16 Feb 09
|
|
pcols = [ ]
|
|
ncols = 4
|
|
nc = int((len(persons) + ncols - 1) / ncols)
|
|
for i in range(ncols):
|
|
pcols.append(persons[i * nc: (i + 1) * nc])
|
|
|
|
notablepersons = []
|
|
# Needed recoding because of Django CVE-2021-45116
|
|
for person in persons:
|
|
if person.bisnotable():
|
|
notablepersons.append(person)
|
|
notablepersons.sort(key=notabilitykey, reverse=True)
|
|
|
|
return render(request,'notablepersons.html', {'persons': persons, 'pcols':pcols, 'notablepersons':notablepersons})
|
|
|
|
|
|
def expedition(request, expeditionname):
|
|
'''Returns a rendered page for one expedition, specified by the year e.g. '2019'.
|
|
If page caching is enabled, it caches the dictionaries used to render the template page.
|
|
|
|
'''
|
|
if request.user.is_authenticated:
|
|
if "reload" in request.GET:
|
|
this_expedition = Expedition.objects.get(year=int(expeditionname))
|
|
# Need to delete the existing entries or we get duplication
|
|
# Need to delete both in the Django ORM and in our own object-store.
|
|
entries = this_expedition.logbookentry_set.all()
|
|
for entry in entries:
|
|
#print(f'! - delete entry: "{entry}"')
|
|
entry.delete()
|
|
entries = this_expedition.logbookentry_set.all()
|
|
LoadLogbookForExpedition(this_expedition)
|
|
logged_in = True
|
|
else:
|
|
logged_in = False
|
|
|
|
|
|
ts = TROG['pagecache']['expedition']
|
|
if settings.CACHEDPAGES:
|
|
nexpos = len( TROG['pagecache']['expedition'])
|
|
#print(f'! - expo {expeditionname} CACHEDPAGES {nexpos} expo pages in cache.')
|
|
if expeditionname in ts:
|
|
#print('! - expo {expeditionanme} using cached page')
|
|
return render(request,'expedition.html', { **ts[expeditionname], 'logged_in' : logged_in })
|
|
|
|
try:
|
|
this_expedition = Expedition.objects.get(year=int(expeditionname))
|
|
except:
|
|
message = f'Expedition not found - database apparently empty, you probably need to do a full re-import of all data.'
|
|
return render(request, 'errors/generic.html', {'message': message})
|
|
|
|
expeditions = Expedition.objects.all()
|
|
personexpeditiondays = [ ]
|
|
dateditems = list(this_expedition.logbookentry_set.all()) + list(this_expedition.survexblock_set.all())
|
|
dates = sorted(set([item.date for item in dateditems]))
|
|
for personexpedition in this_expedition.personexpedition_set.all():
|
|
prow = [ ]
|
|
for date in dates:
|
|
pcell = { "persontrips": PersonTrip.objects.filter(personexpedition=personexpedition,
|
|
logbook_entry__date=date) }
|
|
pcell["survexblocks"] = set(SurvexBlock.objects.filter(survexpersonrole__personexpedition=personexpedition,
|
|
date = date))
|
|
prow.append(pcell)
|
|
personexpeditiondays.append({"personexpedition":personexpedition, "personrow":prow})
|
|
|
|
|
|
ts[expeditionname] = {'expedition': this_expedition, 'expeditions':expeditions,
|
|
'personexpeditiondays':personexpeditiondays, 'settings':settings,
|
|
'dateditems': dateditems}
|
|
TROG['pagecache']['expedition'][expeditionname] = ts[expeditionname]
|
|
nexpos = len( TROG['pagecache']['expedition'])
|
|
#print(f'! - expo {expeditionname} pre-render N expos:{nexpos}')
|
|
return render(request,'expedition.html', { **ts[expeditionname], 'logged_in' : logged_in } )
|
|
|
|
|
|
# def get_absolute_url(self): # seems to have come seriously adrift. This should be in a class?!
|
|
# return ('expedition', (expedition.year))
|
|
|
|
|
|
class Expeditions_tsvListView(ListView):
|
|
"""This uses the Django built-in shortcut mechanism
|
|
It defaults to use a template with name <app-label>/<model-name>_list.html.
|
|
https://www.agiliq.com/blog/2017/12/when-and-how-use-django-listview/
|
|
https://developer.mozilla.org/en-US/docs/Learn/Server-side/Django/Generic_views
|
|
Either a queryset variable or set_queryset() function is used, but not needed
|
|
if you want all the obejcts of a particaulr type in which case just set model = <object>
|
|
"""
|
|
template_name = 'core/expeditions_tsv_list.html' # if not present then uses core/expedition_list.html
|
|
#queryset = Expedition.objects.all()
|
|
#context_object_name = 'expedition'
|
|
model = Expedition # equivalent to .objects.all() for a queryset
|
|
|
|
class Expeditions_jsonListView(ListView):
|
|
template_name = 'core/expeditions_json_list.html'
|
|
model = Expedition
|
|
|
|
|
|
def person(request, first_name='', last_name='', ):
|
|
try:
|
|
this_person = Person.objects.get(first_name = first_name, last_name = last_name)
|
|
except:
|
|
message = f'Person not found \'{first_name} {last_name}\' - possibly Scottish? (See our <a href="/handbook/troggle/namesredesign.html">Proposal to fix this</a>)'
|
|
return render(request, 'errors/generic.html', {'message': message})
|
|
|
|
|
|
return render(request,'person.html', {'person': this_person })
|
|
|
|
|
|
|
|
def get_person_chronology(personexpedition):
|
|
'''Horrible bug here when there is more than one survex block per day, it duplicates the entry but gets it wrong
|
|
Fortunately this is just the display on this page which is wroing, no bad calculations get into the database.
|
|
|
|
This is just a nasty convoluted way of trying the make the template do more work than it is sensible to ask it to do.
|
|
Rewrite more simply with the login in the python, not in Django template language (you bastard Curtis).
|
|
'''
|
|
res = { }
|
|
for persontrip in personexpedition.persontrip_set.all():
|
|
a = res.setdefault(persontrip.logbook_entry.date, { })
|
|
a.setdefault("persontrips", [ ]).append(persontrip)
|
|
|
|
for personrole in personexpedition.survexpersonrole_set.all():
|
|
a = res.setdefault(personrole.survexblock.date, { })
|
|
a.setdefault("personroles", [ ]).append(personrole.survexblock)
|
|
|
|
# build up the tables
|
|
rdates = sorted(list(res.keys()))
|
|
|
|
res2 = [ ]
|
|
for rdate in rdates:
|
|
persontrips = res[rdate].get("persontrips", [])
|
|
personroles = res[rdate].get("personroles", [])
|
|
for n in range(max(len(persontrips), len(personroles) )):
|
|
res2.append(((n == 0 and rdate or "--"), (n < len(persontrips) and persontrips[n]), (n < len(personroles) and personroles[n]) ))
|
|
|
|
return res2
|
|
|
|
|
|
def personexpedition(request, first_name='', last_name='', year=''):
|
|
person = Person.objects.get(first_name = first_name, last_name = last_name)
|
|
this_expedition = Expedition.objects.get(year=year)
|
|
personexpedition = person.personexpedition_set.get(expedition=this_expedition)
|
|
personchronology = get_person_chronology(personexpedition)
|
|
#for pc in personchronology:
|
|
#print(pc)
|
|
return render(request,'personexpedition.html', {'personexpedition': personexpedition, 'personchronology':personchronology})
|
|
|
|
|
|
def logbookentry(request, date, slug):
|
|
this_logbookentry = LogbookEntry.objects.filter(date=date, slug=slug)
|
|
|
|
if this_logbookentry:
|
|
if len(this_logbookentry)>1:
|
|
return render(request, 'object_list.html',{'object_list':this_logbookentry})
|
|
else:
|
|
trips = LogbookEntry.objects.filter(date=date)
|
|
wallets = set()
|
|
refwallets = Wallet.objects.filter(survexblock__date=date)
|
|
for r in refwallets:
|
|
wallets.add(r)
|
|
|
|
allwallets = Wallet.objects.all()
|
|
# Note that w.year() only works for wallets which have a valid JSON file existing
|
|
for w in allwallets:
|
|
if w.date() == date:
|
|
wallets.add(w)
|
|
|
|
thisexpo = this_expedition = Expedition.objects.get(year=int(date[0:4]))
|
|
if thisexpo:
|
|
expeditionday = thisexpo.get_expedition_day(date)
|
|
svxothers = SurvexBlock.objects.filter(expeditionday=expeditionday)
|
|
else:
|
|
svxothers = None
|
|
|
|
this_logbookentry=this_logbookentry[0]
|
|
# This is the only page that uses presontrip_next and persontrip_prev
|
|
# and it is calculated on the fly in the model
|
|
return render(request, 'logbookentry.html',
|
|
{'logbookentry': this_logbookentry, 'trips': trips, 'svxothers': svxothers, 'wallets': wallets})
|
|
else:
|
|
msg =(f' Logbook entry slug:"{slug}" not found in database on date:"{date}" ')
|
|
print(msg)
|
|
return render(request, 'errors/generic.html',{'message':msg})
|
|
|
|
def logbookSearch(request, extra):
|
|
query_string = ''
|
|
found_entries = None
|
|
if ('q' in request.GET) and request.GET['q'].strip():
|
|
query_string = request.GET['q']
|
|
entry_query = search.get_query(query_string, ['text','title',])
|
|
found_entries = LogbookEntry.objects.filter(entry_query)
|
|
|
|
return render(request,'logbooksearch.html',
|
|
{ 'query_string': query_string, 'found_entries': found_entries, })
|
|
|
|
def get_people(request, expeditionslug):
|
|
exp = Expedition.objects.get(year = expeditionslug)
|
|
return render(request,'options.html', {"items": [(pe.slug, pe.name) for pe in exp.personexpedition_set.all()]})
|
|
|
|
def get_logbook_entries(request, expeditionslug):
|
|
exp = Expedition.objects.get(year = expeditionslug)
|
|
return render(request,'options.html', {"items": [(le.slug, f"{le.date} - {le.title}") for le in exp.logbookentry_set.all()]})
|