def controlPanel(request):
jobs_completed = []
if request.method == 'POST':
if request.user.is_superuser:
#importlist is mostly here so that things happen in the correct order.
#http post data seems to come in an unpredictable order, so we do it this way.
importlist = [
'reload_db', 'import_people', 'import_cavetab',
'import_logbooks', 'import_surveys', 'import_QMs'
]
databaseReset.make_dirs()
for item in importlist:
if item in request.POST:
print "running" + " databaseReset." + item + "()"
exec "databaseReset." + item + "()"
jobs_completed.append(item)
else:
if request.user.is_authenticated(
): #The user is logged in, but is not a superuser.
return render_with_context(
request, 'controlPanel.html', {
'caves': Cave.objects.all(),
'error': 'You must be a superuser to use that feature.'
})
else:
return HttpResponseRedirect(reverse('auth_login'))
return render_with_context(
request, 'controlPanel.html', {
'caves': Cave.objects.all(),
'expeditions': Expedition.objects.all(),
'jobs_completed': jobs_completed
})
def cave(request, cave_id='', offical_name=''):
cave = getCave(cave_id)
if cave.non_public and not request.user.is_authenticated():
return render_with_context(request, 'nonpublic.html',
{'instance': cave})
else:
return render_with_context(request, 'cave.html', {'cave': cave})
def logbookentry(request, date, slug):
logbookentry = LogbookEntry.objects.filter(date=date, slug=slug)
if len(logbookentry) > 1:
return render_with_context(request, 'object_list.html',
{'object_list': logbookentry})
else:
logbookentry = logbookentry[0]
return render_with_context(request, 'logbookentry.html',
{'logbookentry': logbookentry})
def personexpedition(request, first_name='', last_name='', year=''):
person = Person.objects.get(first_name=first_name, last_name=last_name)
expedition = Expedition.objects.get(year=year)
personexpedition = person.personexpedition_set.get(expedition=expedition)
personchronology = GetPersonChronology(personexpedition)
return render_with_context(request, 'personexpedition.html', {
'personexpedition': personexpedition,
'personchronology': personchronology
})
def stats(request):
statsDict = {}
statsDict['expoCount'] = int(Expedition.objects.count())
statsDict['caveCount'] = int(Cave.objects.count())
statsDict['personCount'] = int(Person.objects.count())
statsDict['logbookEntryCount'] = int(LogbookEntry.objects.count())
statsDict['dataPointCount'] = int(DataPoint.objects.count())
statsDict['timeseriesCount'] = int(Timeseries.objects.count())
return render_with_context(request, 'statistics.html', statsDict)
def logbook_entry_suggestions(request):
"""
Generates a html box with suggestions about what to do with QMs
in logbook entry text.
"""
unwiki_QM_pattern = r"(?P<whole>(?P<explorer_code>[ABC]?)(?P<cave>\d*)-?(?P<year>\d\d\d?\d?)-(?P<number>\d\d)(?P<grade>[ABCDXV]?))"
unwiki_QM_pattern = re.compile(unwiki_QM_pattern)
#wikilink_QM_pattern=settings.QM_PATTERN
slug = request.POST['slug']
date = request.POST['date']
lbo = LogbookEntry.objects.get(slug=slug, date=date)
#unwiki_QMs=re.findall(unwiki_QM_pattern,lbo.text)
unwiki_QMs = [m.groupdict() for m in unwiki_QM_pattern.finditer(lbo.text)]
print unwiki_QMs
for qm in unwiki_QMs:
#try:
if len(qm['year']) == 2:
if int(qm['year']) < 50:
qm['year'] = '20' + qm['year']
else:
qm['year'] = '19' + qm['year']
if lbo.date.year != int(qm['year']):
try:
lbo = LogbookEntry.objects.get(
date__year=qm['year'],
title__icontains="placeholder for QMs in")
except:
print "failed to get placeholder for year " + str(qm['year'])
temp_QM = QM(found_by=lbo, number=qm['number'], grade=qm['grade'])
temp_QM.grade = qm['grade']
qm['wikilink'] = temp_QM.wiki_link()
#except:
#print 'failed'
print unwiki_QMs
#wikilink_QMs=re.findall(wikilink_QM_pattern,lbo.text)
attached_QMs = lbo.QMs_found.all()
unmentioned_attached_QMs = '' #not implemented, fill this in by subtracting wiklink_QMs from attached_QMs
#Find unattached_QMs. We only look at the QMs with a proper wiki link.
#for qm in wikilink_QMs:
#Try to look up the QM.
print 'got 208'
any_suggestions = True
print 'got 210'
return render_with_context(request, 'suggestions.html', {
'unwiki_QMs': unwiki_QMs,
'any_suggestions': any_suggestions
})
def alarms(request):
caves_missing_logbookentries = []
for cave in Cave.objects.all():
if cave.logbookentry_set.count() == 0:
caves_missing_logbookentries.append(cave)
print caves_missing_logbookentries
return render_with_context(
request, 'alarms.html',
{'caves_missing_logbookentries': caves_missing_logbookentries})
def survexblock(request, survexpath):
survexpath = re.sub("/", ".", survexpath)
print "jjjjjj", survexpath
survexblock = models.SurvexBlock.objects.get(survexpath=survexpath)
#ftext = survexblock.filecontents()
ftext = survexblock.text
return render_with_context(request, 'survexblock.html', {
'survexblock': survexblock,
'ftext': ftext,
})
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_with_context(
request, 'entrance.html', {
'cave': cave,
'entrance': cave_and_ent.entrance,
'letter': cave_and_ent.entrance_letter,
})
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_with_context(request, 'qm.html', locals())
except QM.DoesNotExist:
url = r'/admin/core/qm/add/' + '?' + r'number=' + qm_id
if grade:
url += r'&grade=' + grade
return HttpResponseRedirect(url)
def survey(request, year, wallet_number):
surveys = Survey.objects.all()
expeditions = Expedition.objects.order_by("-year")
current_expedition = Expedition.objects.filter(year=year)[0]
if wallet_number != '':
current_survey = Survey.objects.filter(expedition=current_expedition,
wallet_number=wallet_number)[0]
notes = current_survey.scannedimage_set.filter(contents='notes')
planSketches = current_survey.scannedimage_set.filter(contents='plan')
elevationSketches = current_survey.scannedimage_set.filter(
contents='elevation')
return render_with_context(request, 'survey.html', locals())
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_with_context(request, 'logbooksearch.html', {
'query_string': query_string,
'found_entries': found_entries,
})
def caveindex(request):
caves = Cave.objects.all()
notablecavehrefs = [
"161", "204", "258", "76"
] # could detect notability by trips and notability of people who have been down them
try:
notablecaves = [
Cave.objects.get(kataster_number=kataster_number)
for kataster_number in notablecavehrefs
]
except:
notablecaves = []
return render_with_context(request, 'caveindex.html', {
'caves': caves,
'notablecaves': notablecaves
})
def person(
request,
first_name='',
last_name='',
):
person = Person.objects.get(first_name=first_name, last_name=last_name)
#This is for removing the reference to the user's profile, in case they set it to the wrong person
if request.method == 'GET':
if request.GET.get('clear_profile') == 'True':
person.user = None
person.save()
return HttpResponseRedirect(reverse('profiles_select_profile'))
return render_with_context(request, 'person.html', {
'person': person,
})
def expedition(request, expeditionname):
expedition = Expedition.objects.get(year=int(expeditionname))
expeditions = Expedition.objects.all()
message = ""
if "reload" in request.GET:
message = LoadLogbookForExpedition(expedition)
return render_with_context(
request, 'expedition.html', {
'expedition': expedition,
'expeditions': expeditions,
'message': message,
'settings': settings
})
def get_absolute_url(self):
return ('expedition', (expedition.year))
def todo(request):
message = "no test message" #reverse('personn', kwargs={"name":"hkjhjh"})
if "reloadexpos" in request.GET:
message = LoadPersonsExpos()
message = "Reloaded personexpos"
if "reloadsurvex" in request.POST:
message = LoadAllSurvexBlocks()
message = "Reloaded survexblocks"
expeditions = Expedition.objects.order_by("-year")
totallogbookentries = LogbookEntry.objects.count()
return render_with_context(
request, 'index.html', {
'expeditions': expeditions,
'all': 'all',
'totallogbookentries': totallogbookentries,
"message": message
})
def personindex(request):
persons = Person.objects.all()
# From what I can tell, "persons" seems to be the table rows, while "personss" is the table columns. - AC 16 Feb 09
personss = []
ncols = 4
nc = (len(persons) + ncols - 1) / ncols
for i in range(ncols):
personss.append(persons[i * nc:(i + 1) * nc])
notablepersons = []
for person in Person.objects.all():
if person.bisnotable():
notablepersons.append(person)
return render_with_context(
request, 'personindex.html', {
'persons': persons,
'personss': personss,
'notablepersons': notablepersons,
})
def frontpagetesting(request):
#if request.user.is_authenticated():
#return render_with_context(request,'tasks.html')
expeditions = Expedition.objects.order_by("-year")
# from django.contrib.admin.templatetags import log
return render_with_context(
request, 'frontpagetesting.html', {
'expeditions':
Expedition.objects.order_by("-year"),
'logbookentry':
LogbookEntry,
'cave':
Cave,
'photo':
Photo,
'entrances':
Entrance.objects.filter(caveandentrance__cave__isnull=False),
'entrance':
Entrance,
})
def monthly_stats(request, data_type):
tses = Timeseries.objects.filter(data_type=data_type)
template_file = 'timeseries_stats.html'
#set the defaults
overall_stats = None
plot = False
if request.GET:
pk_list = request.GET.getlist('ts')
print pk_list
tses = tses.filter(logbook_entry__cave__slug__in=pk_list)
print tses
if 'overall' in request.GET:
overall_stats = processing.monthly_stats_multiple(
pk_list, data_type=data_type)
if 'plot' in request.GET:
plot = True
return render_with_context(request, template_file, {
'timeseries': tses,
'overall_stats': overall_stats,
'plot': plot
})
def experimental(request):
legsbyexpo = []
for expedition in Expedition.objects.all():
survexblocks = expedition.survexblock_set.all()
survexlegs = []
survexleglength = 0.0
for survexblock in survexblocks:
survexlegs.extend(survexblock.survexleg_set.all())
survexleglength += survexblock.totalleglength
legsbyexpo.append((expedition, {
"nsurvexlegs": len(survexlegs),
"survexleglength": survexleglength
}))
legsbyexpo.reverse()
survexlegs = models.SurvexLeg.objects.all()
totalsurvexlength = sum([survexleg.tape for survexleg in survexlegs])
return render_with_context(
request, 'experimental.html', {
"nsurvexlegs": len(survexlegs),
"totalsurvexlength": totalsurvexlength,
"legsbyexpo": legsbyexpo
})
def surveyindex(request):
surveys = Survey.objects.all()
expeditions = Expedition.objects.order_by("-year")
return render_with_context(request, 'survey.html', locals())
def personForm(request, pk):
person = Person.objects.get(pk=pk)
form = PersonForm(instance=person)
return render_with_context(request, 'personform.html', {
'form': form,
})
def cave_description(request, cavedescription_name):
cave_description = get_object_or_404(CaveDescription,
short_name=cavedescription_name)
return render_with_context(request, 'cave_description.html', locals())
def availability(request):
return render_with_context(request, 'timeseries_availability.html',
monthly_counts())
def ajax_timeseries_data(request):
num_samples = request.GET.get('num_samples')
#convert to an integer if it exists
if num_samples:
num_samples = int(num_samples)
start_time = request.GET.get('start_time')
end_time = request.GET.get('end_time')
if not request.user.is_authenticated():
form = UnauthTimeseriesDataForm
else:
form = TimeseriesDataForm
if request.GET:
form = form(request.GET)
if form.is_valid():
num_samples = form.cleaned_data['number_of_samples']
start_time = form.cleaned_data['start_time']
end_time = form.cleaned_data['end_time']
number_of_samples = form.cleaned_data['number_of_samples']
ts = form.cleaned_data['timeseries']
if form.cleaned_data['action'] == 'JSON':
#ts=Timeseries.objects.get(pk=ts_pk)
data = ts.data_cropped_resampled(num_samples=num_samples,
time_range_crop=(start_time,
end_time),
style='flot')
return HttpResponse(simplejson.dumps(data),
mimetype="application/javascript")
elif form.cleaned_data['action'] == 'stats':
#ts=Timeseries.objects.get(pk=ts_pk)
start_time, end_time = ts.auto_date_range()
num_samples = ts.datapoint_set.count()
return HttpResponse(simplejson.dumps({
'ts':
ts.pk,
'start_time':
str(start_time),
'end_time':
str(end_time),
'number_of_samples':
num_samples
}),
mimetype="application/javascript")
elif form.cleaned_data['action'] == 'csv':
response = HttpResponse()
export_csv.export_to_csv(
response, (start_time, end_time), (ts, ),
samples_per_ts=number_of_samples
) #it expects a set of timeseries, not just one so we trick it
response[
'Content-Disposition'] = 'attachment; filename=%s%s.csv' % (
'erebus_caves_ts_', ts.pk)
return response
elif form.cleaned_data['action'] == 'matlab':
# note: does not chop dates yet
response = HttpResponse()
response[
'Content-Disposition'] = 'attachment; filename=%s%s.mat' % (
'erebus_caves_ts_', ts.pk)
date_format = '%Y-%m-%d %H:%M:%S'
to_matlab.make_mat(response,
date_range=(start_time, end_time),
ts_pk_list=[ts.pk],
samples_per_ts=number_of_samples)
return response
elif form.cleaned_data['action'] == 'newpage':
return render_with_context(request, 'timeseries_browser.html',
{
'ts_form': form,
'auto_click_submit': True
})
elif form.is_bound:
return render_with_context(request, 'timeseries_browser.html', {
'ts_form': form,
})
else:
form = form()
return render_with_context(request, 'timeseries_browser.html', {
'ts_form': form,
})
