troggle/core/views/caves.py

import os
import string
import re
import settings
import urllib.parse
import subprocess
from pathlib import Path

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
from django.urls import NoReverseMatch

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, CaveFormCodeMirrorPreview, CaveFormTextArea, CaveFormTinyMCE
from .auth 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
'''

todo = '''- Fix rendercave() so that CaveView works
- in getCaves() search GCavelookup first, which should raise a MultpleObjectsReturned exception if no duplicates
'''

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:'{}' START 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:
        # print(f" ! rendercave: slug:'{slug}' survex file:'{cave.survex_file}'")
        try:
            svx3d = Path(cave.survex_file).stem 
            svxstem = Path(settings.SURVEX_DATA) / Path(cave.survex_file)
            # print(f" ! rendercave: slug:'{slug}' '' ++ '{svxstem}'")
        except:
            print(f" ! rendercave: slug:'{slug}' FAIL TO MANAGE survex file:'{cave.survex_file}'")
        # 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.
        # So only do this render if a valid .3d file exists. TO BE DONE -Not yet as CaveView is currently disabled
        # see design docum in troggle/templates/cave.html
        # see rendercave() in troggle/core/views/caves.py
        templatefile = 'cave.html'
        if request.user.is_authenticated:
            editable = True
        else:
            editable = False              
        if not cave_id:
            cave_id = slug # cave.unofficial_number
        context = {'cave_editable': editable, 'settings': settings, 'cave': cave, 'cavepage': True, 
                'cave_id': cave_id, 'svxstem': str(svxstem), 'svx3d':svx3d}
        try:
            r = render(request, templatefile, context) # crashes here with NoReverseMatch if url not set up for 'edit_cave' in urls.py
            return r
        except NoReverseMatch:
            raise
        except:
            message = f'Failed to render cave: {slug}'
            return render(request,'errors/generic.html', {'message': message})

def cavepage(request, karea, subpath):
    '''Displays a cave description page
    accessed by kataster area number specifically
    OR
    accessed by cave.url specifically set in data, e.g. 
    "1623/000/000.html" <= cave-data/1623-000.html
    "1623/41/115.htm" <= cave-data/1623-115.html 
    so we have to query the database to fine the URL as we cannot rely on the url actually telling us the cave by inspection.
    
    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
    '''
    kpath = karea + subpath
    # print(f" ! cavepage:'{kpath}' kataster area:'{karea}' rest of path:'{subpath}'")
    
    try:
        cave = Cave.objects.get(url = kpath) # ideally this will be unique
    except Cave.DoesNotExist:
        # probably a link to text or an image e.g. 1623/161/l/rl89a.htm i.e. an expoweb page
        # cannot assume that this is a simple cave page, for a cave we don't know.
        # print(f" ! cavepage: url={kpath} A cave of this name does not exist")
        return expo.expopage(request, kpath)
    except Cave.MultipleObjectsReturned:
        caves = Cave.objects.filter(url = kpath) 
        # print(f" ! cavepage: url={kpath} multiple caves exist")
        # we should have a -several variant for the cave pages, not just the svxcaves:
        return render(request, 'svxcaveseveral.html', {'settings': settings, "caves":caves })
       
    try:
        r = rendercave(request, cave, cave.slug())
        return r
    except NoReverseMatch:
        raise
    except:
        message = f'Failed to render cave: {kpath} (it does exist and is unique) because of a Django URL resolution error. Check urls.py.'
        return render(request,'errors/generic.html', {'message': message})
        
    # return rendercave(request, cave, cave.slug(), cave_id=cave_id)

def caveEntrance(request, slug):
    try:
        cave = Cave.objects.get(caveslug__slug = slug)
    except:
        return render(request,'errors/badslug.html', {'badslug': 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 test_edit_cave(request, editor = "codemirror"):
    '''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.
    It does NOT yet commit to the git repoSaving is not allowed
    '''
    form_type = {"codemirror": CaveForm, "codemirrorpreview": CaveFormCodeMirrorPreview, "textarea": CaveFormTextArea, "tinymce": CaveFormTinyMCE}[editor]
    
    message = ""
    try:
            cave = Cave.objects.get(caveslug__slug = "1623-264")
    except:
            return render(request,'errors/badslug.html')
    if request.POST:
        form = form_type(request.POST, instance=cave)
        ceFormSet = CaveAndEntranceFormSet(request.POST)
        #versionControlForm = VersionControlCommentForm(request.POST)
        if form.is_valid() and ceFormSet.is_valid():
            pass
        else:
            message = f'! POST data is INVALID {cave}'
            print(message)
    else:
        form = form_type(instance=cave)
        ceFormSet = CaveAndEntranceFormSet(queryset=cave.caveandentrance_set.all())
        #versionControlForm = VersionControlCommentForm()
        
    return render(request, 
                               'editcave.html', 
                               {'form': form, 'cave': cave, 'message': message,
                                'caveAndEntranceFormSet': ceFormSet,
                                'editor': editor,
                                #'versionControlForm': versionControlForm
                                })

@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.
    It does NOT yet commit to the git repo
    '''
    
    message = ""
    if  slug is not None:
        try:
            cave = Cave.objects.get(caveslug__slug = slug)
        except:
            return render(request,'errors/badslug.html', {'badslug': 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()
            try:
                cave.writeDataFile()
                # leave other exceptions unhandled so that they bubble up to user interface
            except PermissionError:
                message = f'CANNOT  save this file.\nPERMISSIONS incorrectly set on server for this file {cave.filename}. Ask a nerd to fix this.'
                return render(request,'errors/generic.html', {'message': message})
            except SubprocessError:
                message = f'CANNOT git on server for this file {cave.filename}. Edits may not be committed.\nAsk a nerd to fix this.'
                return render(request,'errors/generic.html', {'message': message})

            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:
        try:
            cave = Cave.objects.get(caveslug__slug = caveslug)
        except:
            return render(request,'errors/badslug.html', {'badslug': 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()
            try:
                entrance.writeDataFile()
                # leave other exceptions unhandled so that they bubble up to user interface
            except PermissionError:
                message = f'CANNOT  save this file.\nPERMISSIONS incorrectly set on server for this file {entrance.filename}. Ask a nerd to fix this.'
                return render(request,'errors/generic.html', {'message': message})
            except SubprocessError:
                message = f'CANNOT git on server for this file {entrance.filename}. Edits may not be committed.\nAsk a nerd to fix this.'
                return render(request,'errors/generic.html', {'message': message})
            
            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 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):
    try:
        cave = Cave.objects.get(caveslug__slug = caveslug)
    except:
        return render(request,'errors/badslug.html', {'badslug': caveslug})
    return render(request,'options.html', {"items": [(e.entrance.slug(), e.entrance.slug()) for e in cave.entrances()]})

def caveQMs(request, slug):
    try:
        cave = Cave.objects.get(caveslug__slug = slug)
    except:
        return render(request,'errors/badslug.html', {'badslug': 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})

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 get_qms(request, caveslug):
    try:
        cave = Cave.objects.get(caveslug__slug = caveslug)
    except:
        return render(request,'errors/badslug.html', {'badslug': caveslug})
    return render(request,'options.html', {"items": [(e.entrance.slug(), e.entrance.slug()) for e in cave.entrances()]})