code.grnet.gr Git - flowspy/blob - flowspec/views.py

   1 # Create your views here.
   2 import urllib2
   3 import re
   4 import socket
   5 import json
   6 from django import forms
   7 from django.views.decorators.csrf import csrf_exempt
   8 from django.core import urlresolvers
   9 from django.core import serializers
  10 from django.contrib.auth.decorators import login_required
  11 from django.http import HttpResponseRedirect, HttpResponseForbidden, HttpResponse
  12 from django.shortcuts import get_object_or_404, render_to_response
  13 from django.core.context_processors import request
  14 from django.template.context import RequestContext
  15 from django.template.loader import get_template
  16 from django.utils import simplejson
  17 from django.core.urlresolvers import reverse
  18 from django.contrib import messages
  19 from flowspy.accounts.models import *
  20
  21 from django.contrib.auth import authenticate, login
  22
  23 from django.forms.models import model_to_dict
  24
  25 from flowspy.flowspec.forms import *
  26 from flowspy.flowspec.models import *
  27
  28 from copy import deepcopy
  29 from flowspy.utils.decorators import shib_required
  30
  31 def days_offset(): return datetime.now() + timedelta(days = settings.EXPIRATION_DAYS_OFFSET)
  32
  33 @login_required
  34 def user_routes(request):
  35     user_routes = Route.objects.filter(applier=request.user)
  36     return render_to_response('user_routes.html', {'routes': user_routes},
  37                               context_instance=RequestContext(request))
  38
  39 @login_required
  40 def group_routes(request):
  41     group_routes = []
  42     peer = request.user.get_profile().peer
  43     if peer:
  44        peer_members = UserProfile.objects.filter(peer=peer)
  45        users = [prof.user for prof in peer_members]
  46        group_routes = Route.objects.filter(applier__in=users)
  47     return render_to_response('user_routes.html', {'routes': group_routes},
  48                               context_instance=RequestContext(request))
  49
  50
  51 @login_required
  52 def add_route(request):
  53     applier = request.user.pk
  54     if request.method == "GET":
  55         form = RouteForm()
  56         return render_to_response('apply.html', {'form': form, 'applier': applier},
  57                                   context_instance=RequestContext(request))
  58
  59     else:
  60         form = RouteForm(request.POST)
  61         if form.is_valid():
  62             route=form.save(commit=False)
  63             route.applier = request.user
  64             route.expires = days_offset()
  65             route.status = "PENDING"
  66             route.save()
  67             form.save_m2m()
  68             route.commit_add()
  69             return HttpResponseRedirect(reverse("group-routes"))
  70         else:
  71             return render_to_response('apply.html', {'form': form, 'applier':applier},
  72                                       context_instance=RequestContext(request))
  73
  74 @login_required
  75 def add_then(request):
  76     applier = request.user.pk
  77     if request.method == "GET":
  78         form = RouteForm()
  79         return render_to_response('apply.html', {'form': form, 'applier': applier},
  80                                   context_instance=RequestContext(request))
  81
  82     else:
  83         form = RouteForm(request.POST)
  84         if form.is_valid():
  85             route=form.save(commit=False)
  86             route.applier = request.user
  87             route.expires = days_offset()
  88             route.save()
  89             form.save_m2m()
  90             route.commit_add()
  91             return HttpResponseRedirect(reverse("group-routes"))
  92         else:
  93             return render_to_response('apply.html', {'form': form, 'applier':applier},
  94                                       context_instance=RequestContext(request))
  95
  96 @login_required
  97 def edit_route(request, route_slug):
  98     applier = request.user.pk
  99     route_edit = get_object_or_404(Route, name=route_slug)
 100     route_original = deepcopy(route_edit)
 101     if request.POST:
 102         form = RouteForm(request.POST, instance = route_edit)
 103         if form.is_valid():
 104             route=form.save(commit=False)
 105             route.name = route_original.name
 106             route.applier = request.user
 107             route.expires = route_original.expires
 108             route.status = "PENDING"
 109             route.save()
 110             form.save_m2m()
 111             route.commit_edit()
 112             return HttpResponseRedirect(reverse("group-routes"))
 113         else:
 114             return render_to_response('apply.html', {'form': form, 'edit':True, 'applier': applier},
 115                                       context_instance=RequestContext(request))
 116     else:
 117         dictionary = model_to_dict(route_edit, fields=[], exclude=[])
 118         #form = RouteForm(instance=route_edit)
 119         form = RouteForm(dictionary)
 120         return render_to_response('apply.html', {'form': form, 'edit':True, 'applier': applier},
 121                                   context_instance=RequestContext(request))
 122
 123 @login_required
 124 def delete_route(request, route_slug):
 125     if request.is_ajax():
 126         route = get_object_or_404(Route, name=route_slug)
 127         applier_peer = route.applier.get_profile().peer
 128         requester_peer = request.user.get_profile().peer
 129         if applier_peer == requester_peer:
 130             route.deactivate()
 131             route.commit_delete()
 132         html = "<html><body>Done</body></html>"
 133         return HttpResponse(html)
 134     else:
 135         return HttpResponseRedirect(reverse("group-routes"))
 136
 137 @login_required
 138 def user_profile(request):
 139     user = request.user
 140     peer = request.user.get_profile().peer
 141
 142     return render_to_response('profile.html', {'user': user, 'peer':peer},
 143                                   context_instance=RequestContext(request))
 144
 145
 146 def user_login(request):
 147     try:
 148         error_username = None
 149         error_orgname = None
 150         username = request.META['HTTP_EPPN']
 151         if not username:
 152             error_username = True
 153         firstname = request.META['HTTP_SHIB_INETORGPERSON_GIVENNAME']
 154         lastname = request.META['HTTP_SHIB_PERSON_SURNAME']
 155         mail = request.META['HTTP_SHIB_INETORGPERSON_MAIL']
 156         organization = request.META['HTTP_SHIB_HOMEORGANIZATION']
 157         if not organization:
 158             error_orgname = True
 159
 160         if error_orgname or error_username:
 161             error = "Your idP should release the HTTP_EPPN, HTTP_SHIB_HOMEORGANIZATION attributes towards this service"
 162             return render_to_response('error.html', {'error': error,},
 163                                   context_instance=RequestContext(request))
 164         user = authenticate(username=username, firstname=firstname, lastname=lastname, mail=mail, organization=organization, affiliation=None)
 165         if user is not None:
 166             login(request, user)
 167             return HttpResponseRedirect(reverse("group-routes"))
 168                 # Redirect to a success page.
 169                 # Return a 'disabled account' error message
 170         else:
 171             html = "<html><body>Invalid User</body></html>"
 172             return HttpResponse(html)
 173     except Exception as e:
 174         html = "<html><body>Invalid Login Procedure %s </body></html>" %e
 175         return HttpResponse(html)
 176         # Return an 'invalid login' error message.
 177 #    return HttpResponseRedirect(reverse("user-routes"))
 178
 179 @login_required
 180 def add_rate_limit(request):
 181     if request.method == "GET":
 182         form = ThenPlainForm()
 183         return render_to_response('add_rate_limit.html', {'form': form,},
 184                                   context_instance=RequestContext(request))
 185
 186     else:
 187         form = ThenPlainForm(request.POST)
 188         if form.is_valid():
 189             then=form.save(commit=False)
 190             then.action_value = "%sk"%then.action_value
 191             then.save()
 192             response_data = {}
 193             response_data['pk'] = "%s" %then.pk
 194             response_data['value'] = "%s:%s" %(then.action, then.action_value)
 195             return HttpResponse(simplejson.dumps(response_data), mimetype='application/json')
 196         else:
 197             return render_to_response('add_rate_limit.html', {'form': form,},
 198                                       context_instance=RequestContext(request))
 199
 200 @login_required
 201 def add_port(request):
 202     if request.method == "GET":
 203         form = PortPlainForm()
 204         return render_to_response('add_port.html', {'form': form,},
 205                                   context_instance=RequestContext(request))
 206
 207     else:
 208         form = PortPlainForm(request.POST)
 209         if form.is_valid():
 210             port=form.save()
 211             response_data = {}
 212             response_data['value'] = "%s" %port.pk
 213             response_data['text'] = "%s" %port.port
 214             return HttpResponse(simplejson.dumps(response_data), mimetype='application/json')
 215         else:
 216             return render_to_response('add_port.html', {'form': form,},
 217                                       context_instance=RequestContext(request))
 218
 219 @login_required
 220 def user_logout(request):
 221     return HttpResponseRedirect(settings.SHIB_LOGOUT_URL)
 222
 223
 224 def load_jscript(request, file):
 225     return render_to_response('%s.js' % file, context_instance=RequestContext(request), mimetype="text/javascript")