troggle/core/views/other.py

import re

from django import forms
from django.conf import settings
from django.urls import reverse
from django.db.models import Q
from django.http import HttpResponse, HttpResponseRedirect
from django.shortcuts import render
from django.template import Context, loader

import troggle.parsers.imports
from troggle.core.models.troggle import Expedition, Person, PersonExpedition
from troggle.core.models.caves import LogbookEntry, QM, Cave, PersonTrip
from .login import login_required_if_public
from troggle.core.forms import UploadFileForm

'''Utility functions and code to serve the control panel and individual user's 
progress and task list (deprecated as we do not have individual user login).

Also has code to download a logbook in a choice of formats (why?!) and to
download all QMs (not working)
'''

todo = '''Delete the newfile & TripForm code once we have a proper file-upload system working.
meanwhile keep it as an example to consider.

Check that the logbookdownloader works by testing with a round trip.

Use it to convert all older logbooks into the 2005-variant of HTML then we can 
get rid of the parsers for older formats.  There are no images stored in the database, 
so this is only a tool for a first pass, to be followed by extensive hand-editing!
When we have done all the old logbooks, delete this function and the two templates.

But how does this interact with troggle/logbooksdump.py ?S
'''

def todos(request, module): 
    '''produces todo text from module
    We should automate this to find all those strings automatically
    '''
    from troggle.core.TESTS.tests import todo as tests
    from troggle.core.views.logbooks import todo as viewlogbooks
    from troggle.core.forms import todo as forms
    tododict = {'views/other': todo,
        'tests': tests, 
        'views/logbooks': viewlogbooks, 
        'core/forms': forms}
    return render(request,'core/todos.html', {'tododict': tododict})

def troggle404(request): # cannot get this to work. Handler404 in urls.py not right syntax
    '''Custom 404 page to be used even when Debug=True
    https://blog.juanwolf.fr/posts/programming/how-to-create-404-page-django/
    '''
    context = RequestContext(request)
    #context['caves'] = Cave.objects.all()
    return render(request, ('404.html', context.flatten()))

def frontpage(request): 
    '''never seen in common practice. Logon should redirect here when this is more useful'''
    # the messages system does a popup on this page if there is a recent message, e.g. from the admin site actions.
    # via django.contrib.messages.middleware.MessageMiddleware 
    # this is set in the templates.
    if request.user.is_authenticated:
        return render(request,'tasks.html')

    expeditions =  Expedition.objects.order_by("-year")
    logbookentry = LogbookEntry
    cave = Cave
    #from django.contrib.admin.templatetags import log
    return render(request,'frontpage.html', locals())


def controlpanel(request):
    jobs_completed=[]
    if request.method=='POST':
        if request.user.is_superuser: # expoadmin is both .is_staff and ._is_superuser
            # NONE of this works now that databaseReset (now parsers.imports) has been so extensively rewritten
            reinit_db()
            import_caves()
            import_people()
            import_surveyscans()
            import_logbooks()
            import_QMs()
            import_tunnelfiles()
            import_survexblks()
            import_survexpos()
        else:
            if request.user.is_authenticated: #The user is logged in, but is not a superuser.
                return render(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(request,'controlPanel.html', {'caves':Cave.objects.all(),'expeditions':Expedition.objects.all(),'jobs_completed':jobs_completed})


def downloadlogbook(request,year=None,extension=None,queryset=None):
    '''Constructs, from the database, a complete HTML (or TXT) formatted logbook - but TEXT ONLY
    for the current year. Formats available are HTML2005 or 2008text
    
    There are no images stored in the database, so this is only a tool for a first pass, tobe followed by
    extensive hand-editing.
    '''
    
    if year:
        current_expedition=Expedition.objects.get(year=year)
        logbook_entries=LogbookEntry.objects.filter(expedition=current_expedition)
        filename='logbook'+year
    elif queryset:
        logbook_entries=queryset
        filename='logbook'
    else:
        response = HttpResponse(content_type='text/plain')
        return response(r"Error: Logbook downloader doesn't know what year you want")
    
    if 'year' in request.GET:
        year=request.GET['year']
    if 'extension' in request.GET:
        extension=request.GET['extension']

    if extension =='txt':
        response = HttpResponse(content_type='text/plain')
        style='2008'
    elif extension == 'html':
        response = HttpResponse(content_type='text/html')
        style='2005'
    else:
        response = HttpResponse(content_type='text/html')
        style='2005'
        
    template='logbook'+style+'style.'+extension
    response['Content-Disposition'] = 'attachment; filename='+filename+'.'+extension 
    t=loader.get_template(template)
    c={'logbook_entries':logbook_entries}
    response.write(t.render(c))
    return response


def downloadQMs(request):
    # Note to self: use get_cave method for the below
    if request.method=='GET':
        try:
            cave=Cave.objects.get(kataster_number=request.GET['cave_id'])
        except Cave.DoesNotExist:
            cave=Cave.objects.get(name=request.GET['cave_id'])

    from export import toqms

    response = HttpResponse(content_type='text/csv')
    response['Content-Disposition'] = 'attachment; filename=qm.csv'
    toqms.writeQmTable(response,cave)
    return response
    
def ajax_test(request):
    post_text = request.POST['post_data']
    return HttpResponse("{'response_text': '"+post_text+" recieved.'}", 
                                   content_type="application/json")
                                   
def eyecandy(request):
    return 

def ajax_QM_number(request):
    res=""
    if request.method=='POST':
        cave=Cave.objects.get(id=request.POST['cave'])
        print(cave)
        exp=Expedition.objects.get(pk=request.POST['year'])
        print(exp)
        res=cave.new_QM_number(exp.year)

    return HttpResponse(res)

@login_required_if_public
def newfile(request, pslug = None):
    '''     
    If not POST, it goes straight to UploadFileForm using the editfile.html template which is about re-submitting 
    a LBE aka TripReport
    
    If it is POST, then it is a new LBE so an HTML formatted version of it is produced, using template.render()
    and a format 'dataformat/logbookentry.html' which is then put in expoweb/years<year>/autologbook/<LBEnamedfile>
    '''
    if pslug:
        previousfile = LogbookEntry.objects.get(slug = pslug, date = previousdate, expedition = expedition)
    if request.method == 'POST': # If the form has been submitted...
        tripForm = TripForm(request.POST) # A form bound to the POST data
        personTripFormSet = PersonTripFormSet(request.POST)
        if tripForm.is_valid() and personTripFormSet.is_valid(): # All validation rules pass
            dateStr = tripForm.cleaned_data["date"].strftime("%Y-%m-%d")
            directory = os.path.join(settings.EXPOWEB, 
                                   "years", 
                                   expedition.year, 
                                   "autologbook")
            filename = os.path.join(directory, 
                                   dateStr + "." + slugify(tripForm.cleaned_data["title"])[:50] + ".html")
            if not os.path.isdir(directory):
                os.mkdir(directory)
            if pslug and pdate:
                delLogbookEntry(previouslbe)
            f = open(filename, "w")
            template = loader.get_template('dataformat/logbookentry.html')
            context = {'trip': tripForm.cleaned_data, 
                              'persons': personTripFormSet.cleaned_data,
                              'date': dateStr,
                              'expeditionyear': expeditionyear}
            f.write(template.render(context))
            f.close()
            print(logbookparsers.parseAutoLogBookEntry(filename))
            return HttpResponseRedirect(reverse('expedition', args=[expedition.year])) # Redirect after POST
    else:
        if pslug:
            pass
        else:        
            fileform = UploadFileForm() # An unbound form

    return render(request, 'editfile.html', {'fileForm': fileform, })