views.py

from django.http import HttpResponse
from django.http import HttpResponseRedirect, HttpResponseNotFound, HttpResponseBadRequest, Http404
from django.http import HttpResponseForbidden, HttpResponseServerError
from django.template import RequestContext
from django.core.urlresolvers import reverse
from django.shortcuts import render_to_response

from models import Event, Group, EventLog, Label, Tag, Pipeline, Search, GrbEvent
from models import EMGroup, Signoff
from forms import CreateEventForm, EventSearchForm, SimpleSearchForm, SignoffForm

from django.contrib.auth.models import User, Permission
from django.contrib.auth.models import Group as AuthGroup
from django.contrib.contenttypes.models import ContentType
from permission_utils import filter_events_for_user, user_has_perm
from permission_utils import internal_user_required, is_external
from guardian.models import GroupObjectPermission

from view_logic import _createEventFromForm
from view_logic import get_performance_info
from view_logic import get_lvem_perm_status
from view_logic import create_eel
from view_logic import create_emobservation
from view_logic import create_label, delete_label
from view_utils import assembleLigoLw, get_file
from view_utils import flexigridResponse, jqgridResponse
from view_utils import get_recent_events_string
from view_utils import eventLogToDict
from alert import issueAlertForUpdate

# Set up logging
import logging
log = logging.getLogger(__name__)

import os
from django.conf import settings

from buildVOEvent import buildVOEvent, VOEventBuilderException
from utils.vfile import VersionedFile

# XXX This should be configurable / moddable or something
MAX_QUERY_RESULTS = 1000

import datetime, pytz
import json
from django.utils.functional import wraps

# 
# for checking queries in the evnet that the user is external
#
from view_utils import BadFARRange, check_query_far_range
from query import parseQuery, ParseException

#
# A wrapper for retrieving an event and replacing graceid 
# in the arg list with the event itself.  Also checks 
# whether the user is authorized for this event.
#
def event_and_auth_required(view):
    @wraps(view)
    def inner(request, graceid, *args, **kwargs):
        try:
            event = Event.getByGraceid(graceid) 
        except Event.DoesNotExist:
            return HttpResponseNotFound("Event not found.")

        # Check permissions. If the event is specified, 'GET'
        # maps to 'view', and unsafe methods map to 'CHANGE'
        if request.method=='GET':
            if not user_has_perm(request.user, 'view', event):
                return HttpResponseForbidden("Forbidden")
        elif request.method in ['POST', 'DELETE']:                
            if not user_has_perm(request.user, 'change', event):
                return HttpResponseForbidden("Forbidden")

        return view(request, event, *args, **kwargs)
    return inner

def index(request):
#   assert request.user
    context = {}

    signoff_authorized = False
    signoff_instrument = None
    # XXX Note that this may not be the best way to perform the authorization check.
    # In particular, this assumes that the user can only be a member of one group 
    # at a time. That should be the case, however, as the control room machines are 
    # physically well separated and should have different IPs.
    if request.user:
        for group in request.user.groups.all():
            if '_control_room' in group.name:
                signoff_authorized = True
                signoff_instrument = group.name[:2].upper()
                break

    context['signoff_authorized'] = signoff_authorized
    context['signoff_instrument'] = signoff_instrument

    if signoff_authorized:
        label_name = signoff_instrument + 'OPS'

        # Get full list of non-Test events with **OPS label
        events = Event.objects.filter(labelling__label__name=label_name) \
            .exclude(group__name='Test')

        # Split into groups more recent than 1 day and older than 1 day
        one_day_ago = datetime.datetime.utcnow().replace(
            tzinfo=pytz.utc) - datetime.timedelta(days=1)
        new_events = events.filter(created__gte=one_day_ago)
        older_events = events.filter(created__lt=one_day_ago)

        # Put into context dict for template rendering
        context['new_signoff_graceids'] = [e.graceid() for e in new_events]
        context['older_signoff_graceids'] = [e.graceid() for e in older_events]

    recent_events = '' 
    if request.user and not is_external(request.user) and settings.SHOW_RECENT_EVENTS_ON_HOME:
        try:
            recent_events = get_recent_events_string(request)
        except Exception, e:
            pass
    context['recent_events'] = recent_events
    
    return render_to_response('gracedb/index.html', context,
            context_instance=RequestContext(request))

def navbar_only(request):
    return render_to_response('navbar_only.html', {}, context_instance=RequestContext(request))

# SP Info and Privacy pages are required for Federation with InCommon. 
def spinfo(request):
    return render_to_response('gracedb/spinfo.html', {}, context_instance=RequestContext(request))

def spprivacy(request):
    return render_to_response('gracedb/spprivacy.html', {}, context_instance=RequestContext(request))

def discovery(request):
    return render_to_response('discovery.html', {}, context_instance=RequestContext(request))

@event_and_auth_required
def voevent(request, event):
    # Default VOEvent type is 'preliminary'
    voevent_type=request.GET.get('voevent_type', 'preliminary')
    internal=request.GET.get('internal', 1)
    try:
        # Tanner (10/25/2016): need to modify this call to buildVOEvent,
        # second argument should be a serial_number.
        voevent = buildVOEvent(event, voevent_type=voevent_type,
                               request=request, internal=internal)
    # Exceptions caused by user errors of some sort.
    except VOEventBuilderException, e:
        return HttpResponseBadRequest(str(e))
    # All other exceptions return 500.
    except Exception, e:
        return HttpResponseServerError(str(e))
         
    return HttpResponse(voevent, content_type="application/xml")

def create(request):
    d = _create(request)
    if isinstance(d, HttpResponse):
        return d
    else:
        return render_to_response('gracedb/create.html', d,
                                  context_instance=RequestContext(request))

def _create(request):
    assert request.user

    rv = {}

    if request.method == "GET":
        rv['form'] = CreateEventForm()
    else:
        # Check authorization to create.
        group_name = request.POST.get('group', None)
        if not group_name=='Test':
            try:
                pipeline = Pipeline.objects.get(name=request.POST['pipeline'])
            except:
                return HttpResponseBadRequest("No valid pipeline provided.")

            if not user_has_perm(request.user, "populate", pipeline):
                return HttpResponseForbidden("You do not have permission to submit events to this pipeline.")

        form = CreateEventForm(request.POST, request.FILES)
        if form.is_valid():
            event, warnings = _createEventFromForm(request, form)
            if not event:
                # problem creating event...  XXX need an error page for this.
                raise Exception("\n".join(warnings))
            return HttpResponseRedirect(reverse(view, args=[event.graceid()]))
        else:
            rv['form'] = form
    return rv

@event_and_auth_required
def logentry(request, event, num=None):
    """Creates an EventLog from the web interface"""