troggle/core/views/surveys.py

import os, stat
import re
from pathlib import Path
from urllib.parse import urljoin, unquote as urlunquote
from urllib.request import urlopen

from django.conf import settings
from django.shortcuts import render
from django.http import HttpResponse, Http404

from troggle.core.models.survex import Wallet, SingleScan, SurvexBlock, DrawingFile
from troggle.core.views.expo import getmimetype
import parsers.surveys

'''Some of these views serve files as binary blobs, and simply set the mime type based on the file extension,
as does the urls.py dispatcher which sends them here. Here they should actually have the filetype checked 
by looking inside the file before being served.

need to check if inavlid query string is invalid, or produces multiple replies
and render a user-friendly error page.
'''

def scanswallet(request, path):
    #print [ s.walletname  for s in Wallet.objects.all() ]
    try:
        scansfolder = Wallet.objects.get(walletname=urlunquote(path))  
        return render(request, 'scansfolder.html', { 'scansfolder':scansfolder, 'settings': settings })
    except:
        message = f'Scan folder error or not found \'{path}\' .'
        return render(request, 'errors/generic.html', {'message': message})   

def scansingle(request, path, file):
    '''sends a single binary file to the user for display - browser decides how using mimetype
    '''
    try:
        scansfolder = Wallet.objects.get(walletname=urlunquote(path)) 
        singlescan = SingleScan.objects.get(scansfolder=scansfolder, name=file)
        # print(" - scansingle {}:{}:{}:".format(path, file, getmimetype(file)))
        return HttpResponse(content=open(singlescan.ffile,"rb"), content_type=getmimetype(file)) # any type of image
    except:
        message = f'Scan folder or scan item error or not found \'{path}\'  and \'{file}\'.'
        return render(request, 'errors/generic.html', {'message': message})   


def scanswallets(request):
    manyscansfolders = Wallet.objects.all()
    return render(request, 'manyscansfolders.html', { 'manyscansfolders':manyscansfolders, 'settings': settings })
    
    
def dwgdata(request):
    '''Report on all the drawing files in the system. These were loaded by parsing the entire directory tree
    '''
    dwgfiles = DrawingFile.objects.all()
    return render(request, 'dwgfiles.html', { 'dwgfiles':dwgfiles, 'settings': settings })
    

def dwgfilesingle(request, path):
    '''sends a single binary file to the user, We should have a renderer that syntax-colours this Tunnel xml 
    but it might be a Therion file
    '''
    try:
        dwgfile = DrawingFile.objects.get(dwgpath=urlunquote(path)) 
    except:
        message = f'Drawing file error or not found \'{path}\' .'
        return render(request, 'errors/generic.html', {'message': message})   
        
    tfile = Path(settings.TUNNEL_DATA, dwgfile.dwgpath)
    try: # for display not download
        return HttpResponse(content=open(tfile, errors='strict'), content_type="text/xhtml") 
    except UnicodeDecodeError:
        try:
            return HttpResponse(content=open(tfile,encoding='iso-8859-1'), content_type="text/xhtml") 
        except: 
            return HttpResponse(content=open(tfile,mode='rb'), content_type="text/xhtml") 
        else:
            return HttpResponse(content=open(tfile, errors='ignore'), content_type="text/xhtml") 
    else:
        return HttpResponse(content="Unable to understand the encoding for this file: not UTF-8 nor iso-8859-1, or some other read error happened.") 
    
    
def dwgfileupload(request, path):
    '''uploads a drawing file, but where is the Form? This just processes POST info. Apparently unfinished?
    '''
    try:
        dwgfile = DrawingFile.objects.get(dwgpath=urlunquote(path)) # need to check if inavlid query string and produce friendly error
    except:
        message = f'Drawing file error or not found \'{path}\' .'
        return render(request, 'errors/generic.html', {'message': message})   
    tfile = Path(settings.TUNNEL_DATA, dwgfile.dwgpath)
    
    project, user, password, tunnelversion = request.POST["tunnelproject"], request.POST["tunneluser"], request.POST["tunnelpassword"], request.POST["tunnelversion"]
    print(project, user, tunnelversion)
    
    
    if not (len(list(request.FILES.values())) == 1): # "only one file to upload"
         return HttpResponse(content="Error: more than one file selected for upload", content_type="text/plain")
       
    uploadedfile = list(request.FILES.values())[0]
        
    if uploadedfile.field_name != "sketch":
        return HttpResponse(content="Error: non-sketch file uploaded", content_type="text/plain")
    if uploadedfile.content_type != "text/plain":
        return HttpResponse(content="Error: non-plain content type", content_type="text/plain")
        
    # could use this to add new files
    if os.path.split(path)[1] != uploadedfile.name:  
        return HttpResponse(content="Error: name disagrees", content_type="text/plain")
    
    orgsize = dwgfile.filesize   # = os.stat(tfile)[stat.ST_SIZE]
        
    ttext = uploadedfile.read()
    
    # could check that the user and projects agree here
    
    fout = open(tfile, "w")
    fout.write(ttext)
    fout.close()
    
    # redo its settings of 
    parsers.surveys.SetTunnelfileInfo(dwgfile) # commented out
    dwgfile.save()
    
    uploadedfile.close()
    message = "File size %d overwritten with size %d" % (orgsize, dwgfile.filesize)
    return HttpResponse(content=message, content_type="text/plain")