DjNRO

# -*- coding: utf-8 -*- vim:encoding=utf-8:

# vim: tabstop=4:shiftwidth=4:softtabstop=4:expandtab

from django.shortcuts import render_to_response,get_object_or_404,redirect

from django.http import HttpResponse,HttpResponseRedirect,Http404

from django.template import RequestContext

from django.core.urlresolvers import reverse

from django.contrib.auth.decorators import login_required

from django.contrib.auth import logout

from edumanage.models import *

from accounts.models import *

from edumanage.forms import *

from django import forms

from django.forms.models import modelformset_factory

from django.forms.models import inlineformset_factory

from django.contrib.contenttypes.generic import generic_inlineformset_factory

from django.core.mail.message import EmailMessage

from django.contrib.sites.models import Site

from django.template.loader import render_to_string

import json, bz2

import math, datetime

from xml.etree import ElementTree as ET

from django.conf import settings

from django.contrib import messages

from django.db.models import Max

from django.views.decorators.cache import never_cache

from django.utils.translation import ugettext as _

from django.contrib.auth import authenticate, login

from registration.models import RegistrationProfile

from django.core.cache import cache

from edumanage.decorators import social_active_required

from utils.cat_helper import *

@never_cache

def index(request):

    return render_to_response('front/index.html', context_instance=RequestContext(request))

@never_cache

def manage_login_front(request):

    user = request.user

    try:

        profile = user.get_profile()

    except UserProfile.DoesNotExist:

        return render_to_response('edumanage/welcome_manage.html',

                              context_instance=RequestContext(request, base_response(request)))

    except AttributeError:

        return render_to_response('edumanage/welcome_manage.html',

                              context_instance=RequestContext(request, base_response(request)))

    if user.is_authenticated() and user.is_active and profile.is_social_active:

        return redirect(reverse('manage'))

    else:

        return render_to_response('edumanage/welcome_manage.html',

                              context_instance=RequestContext(request, base_response(request)))

@login_required

@social_active_required

@never_cache

def manage(request):

    services_list = []

    servers_list = []

    user = request.user

    try:

        profile = user.get_profile()

        inst = profile.institution

    except UserProfile.DoesNotExist:

        return render_to_response('edumanage/welcome.html',

                              context_instance=RequestContext(request, base_response(request)))

    services = ServiceLoc.objects.filter(institutionid=inst)

    services_list.extend([s for s in services])

    servers = InstServer.objects.filter(instid=inst)

    servers_list.extend([s for s in servers])

    return render_to_response('edumanage/welcome.html', 

                              {

                               'institution': inst, 

                               'services': services_list,

                               'servers': servers_list,                               

                               },  

                              context_instance=RequestContext(request, base_response(request)))

@login_required

@social_active_required

@never_cache

def institutions(request):

    user = request.user

    dict = {}

    try:

        profile = user.get_profile()

        inst = profile.institution

        inst.__unicode__ = inst.get_name(request.LANGUAGE_CODE)

    except UserProfile.DoesNotExist:

        return HttpResponseRedirect(reverse("manage"))

    dict['institution'] = inst.pk

    form = InstDetailsForm(initial=dict)

    form.fields['institution'].widget.attrs['readonly'] = True

    return render_to_response('edumanage/institution.html', 

                              {

                               'institution': inst,

                               'form': form, 

                               },  

                              context_instance=RequestContext(request, base_response(request)))

@login_required

@social_active_required

@never_cache

def add_institution_details(request, institution_pk):

    user = request.user

    try:

        profile = user.get_profile()

        inst = profile.institution

        inst.__unicode__ = inst.get_name(request.LANGUAGE_CODE)

    except UserProfile.DoesNotExist:

        return HttpResponseRedirect(reverse("manage"))

    if institution_pk and int(inst.pk) != int(institution_pk):

        messages.add_message(request, messages.ERROR, 'You have no rights on this Institution')

        return HttpResponseRedirect(reverse("institutions"))

    if request.method == "GET":

        try:         

            inst_details = InstitutionDetails.objects.get(institution=inst)

            form = InstDetailsForm(instance=inst_details)

            UrlFormSet = generic_inlineformset_factory(URL_i18n, extra=2, formset=UrlFormSetFactInst, can_delete=True)

            urls_form = UrlFormSet(prefix='urlsform', instance = inst_details) 

        except InstitutionDetails.DoesNotExist:

            form = InstDetailsForm()

            form.fields['institution'] = forms.ModelChoiceField(queryset=Institution.objects.filter(pk=institution_pk), empty_label=None)

            UrlFormSet =  generic_inlineformset_factory(URL_i18n, extra=2, can_delete=True)

            urls_form = UrlFormSet(prefix='urlsform')

        form.fields['contact'] = forms.ModelMultipleChoiceField(queryset=Contact.objects.filter(pk__in=getInstContacts(inst)))

        return render_to_response('edumanage/institution_edit.html', { 'institution': inst, 'form': form, 'urls_form':urls_form},

                                  context_instance=RequestContext(request, base_response(request)))

    elif request.method == 'POST':

        request_data = request.POST.copy()

        UrlFormSet = generic_inlineformset_factory(URL_i18n, extra=2, formset=UrlFormSetFactInst, can_delete=True)

        try:         

            inst_details = InstitutionDetails.objects.get(institution=inst)

            form = InstDetailsForm(request_data, instance=inst_details)

            urls_form = UrlFormSet(request_data, instance=inst_details, prefix='urlsform')

        except InstitutionDetails.DoesNotExist:

            form = InstDetailsForm(request_data)

            urls_form = UrlFormSet(request_data, prefix='urlsform')

        UrlFormSet = generic_inlineformset_factory(URL_i18n, extra=2, formset=UrlFormSetFactInst, can_delete=True)

        if form.is_valid() and urls_form.is_valid():

            instdets = form.save()

            urls_form.instance = instdets

            urls_inst = urls_form.save()

            return HttpResponseRedirect(reverse("institutions"))

        else:

            form.fields['institution'] = forms.ModelChoiceField(queryset=Institution.objects.filter(pk=institution_pk), empty_label=None)

            form.fields['contact'] = forms.ModelMultipleChoiceField(queryset=Contact.objects.filter(pk__in=getInstContacts(inst)))

            return render_to_response('edumanage/institution_edit.html', { 'institution': inst, 'form': form, 'urls_form': urls_form},

                                  context_instance=RequestContext(request, base_response(request)))

@login_required

@social_active_required

@never_cache

def services(request, service_pk):

    user = request.user

    dict = {}

    try:

        profile = user.get_profile()

        inst = profile.institution

        inst.__unicode__ = inst.get_name(request.LANGUAGE_CODE)

    except UserProfile.DoesNotExist:

        return HttpResponseRedirect(reverse("manage"))

    try:

        instdetails = inst.institutiondetails

    except InstitutionDetails.DoesNotExist:

        return HttpResponseRedirect(reverse("manage"))

    if inst.ertype not in [2,3]:

        messages.add_message(request, messages.ERROR, 'Cannot add/edit Location. Your institution should be either SP or IdP/SP')

        return render_to_response('edumanage/services.html', { 'institution': inst },

                              context_instance=RequestContext(request, base_response(request)))

    try:

        services = ServiceLoc.objects.filter(institutionid = inst)

    except ServiceLoc.DoesNotExist:

        services = False 

    if service_pk:

        try:

            services = services.get(pk=service_pk)

        except:

            messages.add_message(request, messages.ERROR, 'You have no rights to view this location')

            return HttpResponseRedirect(reverse("services"))

        return render_to_response('edumanage/service_details.html', 

                              {

                               'institution': inst,

                               'service': services,

                               },  

                              context_instance=RequestContext(request, base_response(request)))

    return render_to_response('edumanage/services.html', 

                              {

                               'institution': inst,

                               'services': services, 

                               },  

                              context_instance=RequestContext(request, base_response(request)))

@login_required

@social_active_required

@never_cache

def add_services(request, service_pk):

    user = request.user

    service = False

    edit = False

    try:

        profile = user.get_profile()

        inst = profile.institution

        inst.__unicode__ = inst.get_name(request.LANGUAGE_CODE)

    except UserProfile.DoesNotExist:

        return HttpResponseRedirect(reverse("manage"))

    try:

        instdetails = inst.institutiondetails

    except InstitutionDetails.DoesNotExist:

        return HttpResponseRedirect(reverse("manage"))

    if inst.ertype not in [2,3]:

        messages.add_message(request, messages.ERROR, 'Cannot add/edit Service. Your institution should be either SP or IdP/SP')

        return render_to_response('edumanage/services_edit.html', { 'edit': edit },

                                  context_instance=RequestContext(request, base_response(request)))

    if request.method == "GET":

        # Determine add or edit

        try:         

            service = ServiceLoc.objects.get(institutionid=inst, pk=service_pk)

            form = ServiceLocForm(instance=service)

        except ServiceLoc.DoesNotExist:

            form = ServiceLocForm()

            if service_pk:

                messages.add_message(request, messages.ERROR, 'You have no rights to edit this location')

                return HttpResponseRedirect(reverse("services"))

        form.fields['institutionid'] = forms.ModelChoiceField(queryset=Institution.objects.filter(pk=inst.pk), empty_label=None)

        UrlFormSet =  generic_inlineformset_factory(URL_i18n, extra=2, can_delete=True)

        NameFormSet = generic_inlineformset_factory(Name_i18n, extra=2, can_delete=True)

        urls_form = UrlFormSet(prefix='urlsform')

        names_form = NameFormSet(prefix='namesform')

        if (service):

            NameFormSet = generic_inlineformset_factory(Name_i18n, extra=1, formset=NameFormSetFact, can_delete=True)

            names_form = NameFormSet(instance=service, prefix='namesform')

            UrlFormSet = generic_inlineformset_factory(URL_i18n, extra=2, formset=UrlFormSetFact, can_delete=True)

            urls_form = UrlFormSet(instance=service, prefix='urlsform')

        form.fields['contact'] = forms.ModelMultipleChoiceField(queryset=Contact.objects.filter(pk__in=getInstContacts(inst)))

        if service:

            edit = True

        for url_form in urls_form.forms:

            url_form.fields['urltype'] = forms.ChoiceField(choices=(('', '----------'),('info', 'Info'),))

        return render_to_response('edumanage/services_edit.html', { 'form': form, 'services_form':names_form, 'urls_form': urls_form, "edit": edit},

                                  context_instance=RequestContext(request, base_response(request)))

    elif request.method == 'POST':

        request_data = request.POST.copy()

        NameFormSet = generic_inlineformset_factory(Name_i18n, extra=1, formset=NameFormSetFact, can_delete=True)

        UrlFormSet = generic_inlineformset_factory(URL_i18n, extra=2, formset=UrlFormSetFact, can_delete=True)

        try:         

            service = ServiceLoc.objects.get(institutionid=inst, pk=service_pk)

            form = ServiceLocForm(request_data, instance=service)

            names_form = NameFormSet(request_data, instance=service, prefix='namesform')

            urls_form = UrlFormSet(request_data, instance=service, prefix='urlsform')

        except ServiceLoc.DoesNotExist:

            form = ServiceLocForm(request_data)

            names_form = NameFormSet(request_data, prefix='namesform')

            urls_form = UrlFormSet(request_data, prefix='urlsform')

            if service_pk:

                messages.add_message(request, messages.ERROR, 'You have no rights to edit this location')

                return HttpResponseRedirect(reverse("services"))

        if form.is_valid() and names_form.is_valid() and urls_form.is_valid():

            serviceloc = form.save()

            service = serviceloc

            names_form.instance = service

            urls_form.instance = service

            names_inst = names_form.save()

            urls_inst = urls_form.save()

            return HttpResponseRedirect(reverse("services"))

        else:

            form.fields['institutionid'] = forms.ModelChoiceField(queryset=Institution.objects.filter(pk=inst.pk), empty_label=None)

            form.fields['contact'] = forms.ModelMultipleChoiceField(queryset=Contact.objects.filter(pk__in=getInstContacts(inst)))

        if service:

            edit = True

        for url_form in urls_form.forms:

            url_form.fields['urltype'] = forms.ChoiceField(choices=(('', '----------'),('info', 'Info'),))

        return render_to_response('edumanage/services_edit.html', { 'institution': inst, 'form': form, 'services_form':names_form, 'urls_form': urls_form, "edit": edit},

                                  context_instance=RequestContext(request, base_response(request)))

@login_required

@social_active_required

@never_cache

def del_service(request):

    if request.method == 'GET':

        user = request.user

        req_data = request.GET.copy()

        service_pk = req_data['service_pk']

        try:

            profile = user.get_profile()

            institution = profile.institution

        except UserProfile.DoesNotExist:

            resp['error'] = "Could not delete service. Not enough rights"

            return HttpResponse(json.dumps(resp), mimetype='application/json')

        resp = {}

        try:

            service = ServiceLoc.objects.get(institutionid=institution, pk=service_pk)

        except ServiceLoc.DoesNotExist:

            resp['error'] = "Could not get service or you have no rights to delete"

            return HttpResponse(json.dumps(resp), mimetype='application/json')

        try:

            service.delete()

        except:

            resp['error'] = "Could not delete service"

            return HttpResponse(json.dumps(resp), mimetype='application/json')

        resp['success'] = "Service successfully deleted"

        return HttpResponse(json.dumps(resp), mimetype='application/json')

@login_required

@social_active_required

@never_cache

def servers(request, server_pk):

    user = request.user

    servers = False

    try:

        profile = user.get_profile()

        inst = profile.institution

    except UserProfile.DoesNotExist:

        inst = False

        return HttpResponseRedirect(reverse("manage"))

    if inst:

        servers = InstServer.objects.filter(instid=inst)

    if server_pk:

        servers = servers.get(pk=server_pk)

        return render_to_response('edumanage/server_details.html', 

                              {

                               'institution': inst,

                               'server': servers,

                               },  

                              context_instance=RequestContext(request, base_response(request)))

    return render_to_response('edumanage/servers.html', { 'servers': servers},

                                  context_instance=RequestContext(request, base_response(request)))

@login_required

@social_active_required

@never_cache

def add_server(request, server_pk):

    user = request.user

    server = False

    edit = False

    try:

        profile = user.get_profile()

        inst = profile.institution

        inst.__unicode__ = inst.get_name(request.LANGUAGE_CODE)

    except UserProfile.DoesNotExist:

        return HttpResponseRedirect(reverse("manage"))

    try:

        instdetails = inst.institutiondetails

    except InstitutionDetails.DoesNotExist:

        return HttpResponseRedirect(reverse("manage"))

    if request.method == "GET":

        # Determine add or edit

        try:         

            server = InstServer.objects.get(instid=inst, pk=server_pk)

            form = InstServerForm(instance=server)

        except InstServer.DoesNotExist:

            form = InstServerForm()

            if server_pk:

                messages.add_message(request, messages.ERROR, 'You have no rights to edit this server')

                return HttpResponseRedirect(reverse("servers"))  

        form.fields['instid'] = forms.ModelChoiceField(queryset=Institution.objects.filter(pk=inst.pk), empty_label=None)

        if server:

            edit = True

        return render_to_response('edumanage/servers_edit.html', { 'form': form, 'edit': edit },

                                  context_instance=RequestContext(request, base_response(request)))

    elif request.method == 'POST':

        request_data = request.POST.copy()

        try:         

            server = InstServer.objects.get(instid=inst, pk=server_pk)

            form = InstServerForm(request_data, instance=server)

        except InstServer.DoesNotExist:

            form = InstServerForm(request_data)

            if server_pk:

                messages.add_message(request, messages.ERROR, 'You have no rights to edit this server')

                return HttpResponseRedirect(reverse("servers")) 

        if form.is_valid():

            instserverf = form.save()

            return HttpResponseRedirect(reverse("servers"))

        else:

            form.fields['instid'] = forms.ModelChoiceField(queryset=Institution.objects.filter(pk=inst.pk), empty_label=None)

        if server:

            edit = True

        return render_to_response('edumanage/servers_edit.html', { 'institution': inst, 'form': form, 'edit': edit },

                                  context_instance=RequestContext(request, base_response(request)))

@login_required

@social_active_required

@never_cache

def cat_enroll(request):

    user = request.user

    edit = False

    cat_url = None

    inst_uid = None

    try:

        profile = user.get_profile()

        inst = profile.institution

        inst.__unicode__ = inst.get_name(request.LANGUAGE_CODE)

    except UserProfile.DoesNotExist:

        return HttpResponseRedirect(reverse("manage"))

    try:

        instdetails = inst.institutiondetails

    except InstitutionDetails.DoesNotExist:

        return HttpResponseRedirect(reverse("manage"))

    if inst.ertype not in [1,3]:

        messages.add_message(request, messages.ERROR, 'Cannot add/edit Realms. Your institution should be either IdP or IdP/SP')

        return render_to_response('edumanage/catenroll.html', { 'status':False },

                                  context_instance=RequestContext(request, base_response(request)))

    if request.method == "GET":

        current_enrollments = inst.catenrollment_set.all()

        current_enrollments_list = current_enrollments.values_list('cat_instance', flat=True)

        available_enrollments = [(x[0], x[1]) for x in settings.CAT_INSTANCES if x[0] not in current_enrollments_list]

        if len(available_enrollments) == 0:

            messages.add_message(request, messages.ERROR, 'There are no available CAT instances for your institution enrollment')

            return render_to_response('edumanage/catenroll.html', { 'status': False, 'cat_instances': available_enrollments},

                                  context_instance=RequestContext(request, base_response(request)))

        return render_to_response('edumanage/catenroll.html', { 'status': True, 'current_enrollments': current_enrollments, 'cat_instances': available_enrollments},

                                  context_instance=RequestContext(request, base_response(request)))

    elif request.method == 'POST':

        request_data = request.POST.copy()

        instance = request_data['catinstance']

        #Check if cat enrollment exists. It should not! 

        if inst.catenrollment_set.filter(cat_instance=instance):

            messages.add_message(request, messages.ERROR, 'There is already and enrollment for this CAT instance')

            return HttpResponseRedirect(reverse("catenroll"))

        try:

            cat_instance = settings.CAT_AUTH[instance]

        except:

            messages.add_message(request, messages.ERROR, 'Invalid CAT instance')

            return HttpResponseRedirect(reverse("catenroll"))

        cat_api_key = cat_instance['CAT_API_KEY']

        cat_api_url = cat_instance['CAT_API_URL']

        enroll = CatQuery(cat_api_key, cat_api_url)

        params = {'NEWINST_PRIMARYADMIN': u"%s"%user.email,

                    'option[S1]': 'general:instname',

                    'value[S1-0]': u"%s"%inst.get_name('en'),

                    'value[S1-lang]': 'en'}

        newinst = enroll.newinst(params)

        cat_url = None

        inst_uid = None

        if newinst:

            # this should be True only for successful postings

            status = enroll.status

            response = enroll.response

            inst_uid = response['inst_unique_id']

            cat_url = response['enrollment_URL']

            catentry = CatEnrollment()

            catentry.cat_inst_id = inst_uid

            catentry.inst = inst

            catentry.url = cat_url

            catentry.applier = user

            catentry.cat_instance = instance

            catentry.save()

            # We should notify the user

        else:

            status = enroll.status

            response = enroll.response

        return render_to_response('edumanage/catenroll.html', { 'status': True, 'response_status': status, 'response': response, 'cat_url':cat_url, 'inst_uid': inst_uid},

                                  context_instance=RequestContext(request, base_response(request)))

@login_required

@social_active_required

@never_cache

def del_server(request):

    if request.method == 'GET':

        user = request.user

        req_data = request.GET.copy()

        server_pk = req_data['server_pk']

        try:

            profile = user.get_profile()

            institution = profile.institution

        except UserProfile.DoesNotExist:

            resp['error'] = "Could not delete server. Not enough rights"

            return HttpResponse(json.dumps(resp), mimetype='application/json')

        resp = {}

        try:

            server = InstServer.objects.get(instid=institution, pk=server_pk)

        except InstServer.DoesNotExist:

            resp['error'] = "Could not get server or you have no rights to delete"

            return HttpResponse(json.dumps(resp), mimetype='application/json')

        try:

            server.delete()

        except:

            resp['error'] = "Could not delete server"

            return HttpResponse(json.dumps(resp), mimetype='application/json')

        resp['success'] = "Server successfully deleted"

        return HttpResponse(json.dumps(resp), mimetype='application/json')

@login_required

@social_active_required

@never_cache

def realms(request):

    user = request.user

    servers = False

    try:

        profile = user.get_profile()

        inst = profile.institution

    except UserProfile.DoesNotExist:

        return HttpResponseRedirect(reverse("manage"))

    if inst:

        realms = InstRealm.objects.filter(instid=inst)

    if inst.ertype not in [1,3]:

        messages.add_message(request, messages.ERROR, 'Cannot add/edit Realms. Your institution should be either IdP or IdP/SP')

    return render_to_response('edumanage/realms.html', { 'realms': realms },

                                  context_instance=RequestContext(request, base_response(request)))

@login_required

@social_active_required

@never_cache

def add_realm(request, realm_pk):

    user = request.user

    server = False

    realm = False

    edit = False

    try:

        profile = user.get_profile()

        inst = profile.institution

        inst.__unicode__ = inst.get_name(request.LANGUAGE_CODE)

    except UserProfile.DoesNotExist:

        return HttpResponseRedirect(reverse("manage"))

    try:

        instdetails = inst.institutiondetails

    except InstitutionDetails.DoesNotExist:

        return HttpResponseRedirect(reverse("manage"))

    if inst.ertype not in [1,3]:

        messages.add_message(request, messages.ERROR, 'Cannot add/edit Realm. Your institution should be either IdP or IdP/SP')

        return render_to_response('edumanage/realms_edit.html', { 'edit': edit },

                                  context_instance=RequestContext(request, base_response(request)))

    if request.method == "GET":

        # Determine add or edit

        try:         

            realm = InstRealm.objects.get(instid=inst, pk=realm_pk)

            form = InstRealmForm(instance=realm)

        except InstRealm.DoesNotExist:

            form = InstRealmForm()

            if realm_pk:

                messages.add_message(request, messages.ERROR, 'You have no rights to edit this realm')

                return HttpResponseRedirect(reverse("realms"))

        form.fields['instid'] = forms.ModelChoiceField(queryset=Institution.objects.filter(pk=inst.pk), empty_label=None)

        form.fields['proxyto'] = forms.ModelMultipleChoiceField(queryset=InstServer.objects.filter(pk__in=getInstServers(inst, True)))

        if realm:

            edit = True

        return render_to_response('edumanage/realms_edit.html', { 'form': form, 'edit': edit },

                                  context_instance=RequestContext(request, base_response(request)))

    elif request.method == 'POST':

        request_data = request.POST.copy()

        try:         

            realm = InstRealm.objects.get(instid=inst, pk=realm_pk)

            form = InstRealmForm(request_data, instance=realm)

        except InstRealm.DoesNotExist:

            form = InstRealmForm(request_data)

            if realm_pk:

                messages.add_message(request, messages.ERROR, 'You have no rights to edit this realm')

                return HttpResponseRedirect(reverse("realms")) 

        if form.is_valid():

            instserverf = form.save()

            return HttpResponseRedirect(reverse("realms"))

        else:

            form.fields['instid'] = forms.ModelChoiceField(queryset=Institution.objects.filter(pk=inst.pk), empty_label=None)

            form.fields['proxyto'] = forms.ModelMultipleChoiceField(queryset=InstServer.objects.filter(pk__in=getInstServers(inst, True)))

        if realm:

            edit = True

        return render_to_response('edumanage/realms_edit.html', { 'institution': inst, 'form': form, 'edit': edit },

                                  context_instance=RequestContext(request, base_response(request)))

@login_required

@social_active_required

@never_cache

def del_realm(request):

    if request.method == 'GET':

        user = request.user

        req_data = request.GET.copy()

        realm_pk = req_data['realm_pk']

        try:

            profile = user.get_profile()

            institution = profile.institution

        except UserProfile.DoesNotExist:

            resp['error'] = "Not enough rights"

            return HttpResponse(json.dumps(resp), mimetype='application/json')

        resp = {}

        try:

            realm = InstRealm.objects.get(instid=institution, pk=realm_pk)

        except InstRealm.DoesNotExist:

            resp['error'] = "Could not get realm or you have no rights to delete"

            return HttpResponse(json.dumps(resp), mimetype='application/json')

        try:

            realm.delete()

        except:

            resp['error'] = "Could not delete realm"

            return HttpResponse(json.dumps(resp), mimetype='application/json')

        resp['success'] = "Realm successfully deleted"

        return HttpResponse(json.dumps(resp), mimetype='application/json')

@login_required

@social_active_required

@never_cache

def contacts(request):

    user = request.user

    servers = False

    instcontacts = []

    try:

        profile = user.get_profile()

        inst = profile.institution

        inst.__unicode__ = inst.get_name(request.LANGUAGE_CODE)

    except UserProfile.DoesNotExist:

        return HttpResponseRedirect(reverse("manage"))

    try:

        instdetails = inst.institutiondetails

    except InstitutionDetails.DoesNotExist:

        return HttpResponseRedirect(reverse("manage"))

    if inst:

        instcontacts.extend([x.contact.pk for x in InstitutionContactPool.objects.filter(institution=inst)])

        contacts = Contact.objects.filter(pk__in=instcontacts)

    return render_to_response('edumanage/contacts.html', { 'contacts': contacts},

                                  context_instance=RequestContext(request, base_response(request)))

@login_required

@social_active_required

@never_cache

def add_contact(request, contact_pk):

    user = request.user

    server = False

    edit = False

    contact = False

    try:

        profile = user.get_profile()

        inst = profile.institution

        inst.__unicode__ = inst.get_name(request.LANGUAGE_CODE)

    except UserProfile.DoesNotExist:

        return HttpResponseRedirect(reverse("manage"))

    try:

        instdetails = inst.institutiondetails

    except InstitutionDetails.DoesNotExist:

        return HttpResponseRedirect(reverse("manage"))

    if request.method == "GET":

        # Determine add or edit

        try:         

            contactinst = InstitutionContactPool.objects.get(institution=inst, contact__pk=contact_pk)

            contact = contactinst.contact

            form = ContactForm(instance=contact)

        except InstitutionContactPool.DoesNotExist:

            form = ContactForm()

            if contact_pk:

                messages.add_message(request, messages.ERROR, 'You have no rights to edit this contact')

                return HttpResponseRedirect(reverse("contacts"))

        if contact:

            edit = True

        return render_to_response('edumanage/contacts_edit.html', { 'form': form, "edit" : edit},

                                  context_instance=RequestContext(request, base_response(request)))

    elif request.method == 'POST':

        request_data = request.POST.copy()

        try:         

            contactinst = InstitutionContactPool.objects.get(institution=inst, contact__pk=contact_pk)

            contact = contactinst.contact

            form = ContactForm(request_data, instance=contact)

        except InstitutionContactPool.DoesNotExist:

            form = ContactForm(request_data)

            if contact_pk:

                messages.add_message(request, messages.ERROR, 'You have no rights to edit this contact')

                return HttpResponseRedirect(reverse("contacts"))

        if form.is_valid():

            contact = form.save()

            instContPool, created = InstitutionContactPool.objects.get_or_create(contact=contact, institution=inst)

            instContPool.save()

            return HttpResponseRedirect(reverse("contacts"))

        if contact:

            edit = True

        return render_to_response('edumanage/contacts_edit.html', { 'form': form, "edit": edit},

                                  context_instance=RequestContext(request, base_response(request)))

@login_required

@social_active_required

@never_cache

def del_contact(request):

    if request.method == 'GET':

        user = request.user

        req_data = request.GET.copy()

        contact_pk = req_data['contact_pk']

        try:

            profile = user.get_profile()

            institution = profile.institution

        except UserProfile.DoesNotExist:

            resp['error'] = "Could not delete contact. Not enough rights"

            return HttpResponse(json.dumps(resp), mimetype='application/json')

        resp = {}

        try:

            contactinst = InstitutionContactPool.objects.get(institution=institution, contact__pk=contact_pk)

            contact = contactinst.contact

        except InstitutionContactPool.DoesNotExist:

            resp['error'] = "Could not get contact or you have no rights to delete"

            return HttpResponse(json.dumps(resp), mimetype='application/json')

        try:

            for service in ServiceLoc.objects.filter(institutionid=institution):

                if (contact in service.contact.all() and len(service.contact.all()) == 1):

                    resp['error'] = "Could not delete contact. It is the only contact in service <b>%s</b>.<br>Fix it and try again" %service.get_name(lang="en")

                    return HttpResponse(json.dumps(resp), mimetype='application/json')

            if (contact in institution.institutiondetails.contact.all() and len(institution.institutiondetails.contact.all()) == 1):

                    resp['error'] = "Could not delete contact. It is the only contact your institution.<br>Fix it and try again"

                    return HttpResponse(json.dumps(resp), mimetype='application/json')

            contact.delete()

        except Exception:

            resp['error'] = "Could not delete contact"

            return HttpResponse(json.dumps(resp), mimetype='application/json')

        resp['success'] = "Contact successfully deleted"

        return HttpResponse(json.dumps(resp), mimetype='application/json')

@login_required

@social_active_required

@never_cache

def instrealmmon(request):

    user = request.user

    servers = False

    instcontacts = []

    try:

        profile = user.get_profile()

        inst = profile.institution

        inst.__unicode__ = inst.get_name(request.LANGUAGE_CODE)

    except UserProfile.DoesNotExist:

        return HttpResponseRedirect(reverse("manage"))

    try:

        instdetails = inst.institutiondetails

    except InstitutionDetails.DoesNotExist:

        return HttpResponseRedirect(reverse("manage"))

    if inst:

        instrealmmons = InstRealmMon.objects.filter(realm__instid=inst)

    return render_to_response('edumanage/instrealmmons.html', { 'realms': instrealmmons},

                                  context_instance=RequestContext(request, base_response(request)))

@login_required

@social_active_required

@never_cache

def add_instrealmmon(request, instrealmmon_pk):

    user = request.user

    instrealmmon = False

    edit = False

    try:

        profile = user.get_profile()

        inst = profile.institution

        inst.__unicode__ = inst.get_name(request.LANGUAGE_CODE)

    except UserProfile.DoesNotExist:

        return HttpResponseRedirect(reverse("manage"))

    try:

        instdetails = inst.institutiondetails

    except InstitutionDetails.DoesNotExist: