troggle/core/views_other.py

from troggle.core.models import Cave, Expedition, Person, LogbookEntry, PersonExpedition, PersonTrip, DPhoto, QM
from troggle.core.forms import UploadFileForm
from django.conf import settings
from django import forms
from django.template import loader, Context
from django.db.models import Q
import databaseReset
import re
from django.http import HttpResponse, HttpResponseRedirect
from django.core.urlresolvers import reverse
from utils import render_with_context
from core.models import *
from troggle.helper import login_required_if_public

def showrequest(request):
    return HttpResponse(request.GET)

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())
    return render_with_context(request,'statistics.html', statsDict)

def frontpage(request):
    if request.user.is_authenticated():
        return render_with_context(request,'tasks.html')

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

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 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 downloadCavetab(request):
    from export import tocavetab
    response = HttpResponse(mimetype='text/csv')
    response['Content-Disposition'] = 'attachment; filename=CAVETAB2.CSV'
    tocavetab.writeCaveTab(response)
    return response

def downloadSurveys(request):
    from export import tosurveys
    response = HttpResponse(mimetype='text/csv')
    response['Content-Disposition'] = 'attachment; filename=Surveys.csv'
    tosurveys.writeCaveTab(response)
    return response

def downloadLogbook(request,year=None,extension=None,queryset=None):
    
    if year:
        expedition=Expedition.objects.get(year=year)
        logbook_entries=LogbookEntry.objects.filter(expedition=expedition)
        filename='logbook'+year
    elif queryset:
        logbook_entries=queryset
        filename='logbook'
    else:
        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(mimetype='text/plain')
        style='2008'
    elif extension == 'html':
        response = HttpResponse(mimetype='text/html')
        style='2005'
        
    template='logbook'+style+'style.'+extension
    response['Content-Disposition'] = 'attachment; filename='+filename+'.'+extension 
    t=loader.get_template(template)
    c=Context({'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=cave_id)

    from export import toqms

    response = HttpResponse(mimetype='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.'}", 
                                   mimetype="application/json")
                                   
def eyecandy(request):
    return 

def ajax_QM_number(request):
    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)

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
        })

@login_required_if_public
def newFile(request, pslug = None):
#    if pslug:
#        previousfile = LogbookEntry.objects.get(slug = pslug, date = previousdate, expedition = expedition)
#        assert previousfile.filename
    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 = 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
#            if previouslbe.cave:
#                tripForm = TripForm(initial={"date": previousdate,
#                                             "title": previouslbe.title,
#                                             "cave": previouslbe.cave.reference(),
#                                             "location": None,
#                                             "caveOrLocation": "cave",
#                                             "html": previouslbe.text})
#            else:
#                tripForm = TripForm(initial={"date": previousdate,
#                                             "title": previouslbe.title,
#                                             "cave": None,
#                                             "location": previouslbe.place,
#                                             "caveOrLocation": "location",
#                                             "html": previouslbe.text})
#            personTripFormSet = PersonTripFormSet(initial=[{"name": get_name(py.personexpedition), 
#                                                            "TU": py.time_underground, 
#                                                            "author": py.is_logbook_entry_author}
#                                                           for py in previouslbe.persontrip_set.all()])
        else:        
            fileform = UploadFileForm() # An unbound form

    return render_with_context(request, 'editfile.html', {
        'fileForm': fileform,

    })

@login_required_if_public
def deleteFile(request, expeditionyear, date = None, slug = None):
    expedition = Expedition.objects.get(year=expeditionyear)
    previousdate = datetime.date(*[int(x) for x in date.split("-")])
    previouslbe = LogbookEntry.objects.get(slug = slug, date = previousdate, expedition = expedition)
    delLogbookEntry(previouslbe)
    return HttpResponseRedirect(reverse('expedition', args=[expedition.year])) # Redirect after POST

def delFile(f):
    for pt in lbe.persontrip_set.all():
        pt.delete()
    lbe.delete()
    os.remove(lbe.filename)