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

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 edumanage.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

import json 

import math

from xml.etree import ElementTree as ET

from django.conf import settings

def index(request):

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

@login_required

def manage(request):

    services_list = []

    servers_list = []

    user = request.user

    try:

        profile = user.get_profile()

        inst = profile.institution

    except UserProfile.DoesNotExist:

        inst = False

    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

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:

        inst = False

    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

def add_institution_details(request, institution_pk):

    user = request.user

    try:

        profile = user.get_profile()

        inst = profile.institution

    except UserProfile.DoesNotExist:

        inst = False

    if (not inst) or (int(inst.pk) != int(institution_pk)):

    #            messages.add_message(request, messages.WARNING,

    #                             _("Insufficient rights on Institution. Contact your administrator"))

        return HttpResponseRedirect(reverse("institutions"))

    if request.method == "GET":

        # Determine add or edit

        request_data = request.POST.copy()

        try:         

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

            form = InstDetailsForm(instance=inst_details)

        except InstitutionDetails.DoesNotExist:

            form = InstDetailsForm()

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

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

    elif request.method == 'POST':

        request_data = request.POST.copy()

        try:         

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

            form = InstDetailsForm(request_data, instance=inst_details)

        except InstitutionDetails.DoesNotExist:

            form = InstDetailsForm(request_data)

        if form.is_valid():

            instdets = form.save()

            return HttpResponseRedirect(reverse("institutions"))

        else:

            try:

                profile = user.get_profile()

                inst = profile.institution

            except UserProfile.DoesNotExist:

                inst = False

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

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

@login_required

def services(request):

    user = request.user

    dict = {}

    try:

        profile = user.get_profile()

        inst = profile.institution

    except UserProfile.DoesNotExist:

        inst = False

    try:

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

    except ServiceLoc.DoesNotExist:

        services = False 

    return render_to_response('edumanage/services.html', 

                              {

                               'institution': inst,

                               'services': services, 

                               },  

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

@login_required

def add_services(request, service_pk):

    user = request.user

    service = False

    try:

        profile = user.get_profile()

        inst = profile.institution

    except UserProfile.DoesNotExist:

        inst = False

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

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

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

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

#            for nform in names_inst:

#                nform.content_object = serviceloc

#                nform.save()

#            for uform in urls_inst:

#                uform.content_object = serviceloc

#                uform.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)))

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

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

@login_required

def get_service_points(request):

    if request.method == "GET":

        user = request.user

        try:

            profile = user.get_profile()

            inst = profile.institution

        except UserProfile.DoesNotExist:

            inst = False

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

        locs = []

        for sl in servicelocs:

            response_location = {}

            response_location['lat'] = u"%s"%sl.latitude

            response_location['lng'] = u"%s"%sl.longitude

            response_location['address'] = u"%s<br>%s"%(sl.address_street, sl.address_city)

            response_location['enc'] = u"%s"%(sl.enc_level)

            response_location['AP_no'] = u"%s"%(sl.AP_no)

            response_location['name'] = sl.loc_name.get(lang='en').name

            response_location['port_restrict'] = u"%s"%(sl.port_restrict)

            response_location['transp_proxy'] = u"%s"%(sl.transp_proxy)

            response_location['IPv6'] = u"%s"%(sl.IPv6)

            response_location['NAT'] = u"%s"%(sl.NAT)

            response_location['wired'] = u"%s"%(sl.wired)

            response_location['SSID'] = u"%s"%(sl.SSID)

            response_location['key'] = u"%s"%sl.pk

            locs.append(response_location)

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

    else:

       return HttpResponseNotFound('<h1>Something went really wrong</h1>')

def get_all_services(request):

    servicelocs = ServiceLoc.objects.all()

    locs = []

    for sl in servicelocs:

        response_location = {}

        response_location['lat'] = u"%s"%sl.latitude

        response_location['lng'] = u"%s"%sl.longitude

        response_location['address'] = u"%s<br>%s"%(sl.address_street, sl.address_city)

        response_location['enc'] = u"%s"%(sl.enc_level)

        response_location['AP_no'] = u"%s"%(sl.AP_no)

        response_location['inst'] = sl.institutionid.org_name.get(lang='en').name

        response_location['name'] = sl.loc_name.get(lang='en').name

        response_location['port_restrict'] = u"%s"%(sl.port_restrict)

        response_location['transp_proxy'] = u"%s"%(sl.transp_proxy)

        response_location['IPv6'] = u"%s"%(sl.IPv6)

        response_location['NAT'] = u"%s"%(sl.NAT)

        response_location['wired'] = u"%s"%(sl.wired)

        response_location['SSID'] = u"%s"%(sl.SSID)

        response_location['key'] = u"%s"%sl.pk

        locs.append(response_location)

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

def servers(request):

    user = request.user

    servers = False

    try:

        profile = user.get_profile()

        inst = profile.institution

    except UserProfile.DoesNotExist:

        inst = False

    if inst:

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

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

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

@login_required

def adduser(request):

    user = request.user

    try:

        profile = user.get_profile()

        inst = profile.institution

    except UserProfile.DoesNotExist:

        inst = False

    if request.method == "GET":

        form = ContactForm()

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

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

    elif request.method == 'POST':

        request_data = request.POST.copy()

        form = ContactForm(request_data)

        if form.is_valid():

            contact = form.save()

            instContPool = InstitutionContactPool(contact=contact, institution=inst)

            instContPool.save()

            response_data = {}

            response_data['value'] = "%s" %contact.pk

            response_data['text'] = "%s" %contact

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

        else:

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

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

@login_required

def add_server(request, server_pk):

    user = request.user

    server = False

    try:

        profile = user.get_profile()

        inst = profile.institution

    except UserProfile.DoesNotExist:

        inst = False

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

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

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

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

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

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

@login_required

def realms(request):

    user = request.user

    servers = False

    try:

        profile = user.get_profile()

        inst = profile.institution

    except UserProfile.DoesNotExist:

        inst = False

    if inst:

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

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

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

@login_required

def add_realm(request, realm_pk):

    user = request.user

    server = False

    try:

        profile = user.get_profile()

        inst = profile.institution

    except UserProfile.DoesNotExist:

        inst = False

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

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

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

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

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

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

@login_required

def del_realm(request):

    if request.method == 'GET':

        user = request.user

        req_data = request.GET.copy()

        realm_pk = req_data['realm_pk']

        profile = user.get_profile()

        institution = profile.institution

        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

def contacts(request):

    user = request.user

    servers = False

    instcontacts = []

    try:

        profile = user.get_profile()

        inst = profile.institution

    except UserProfile.DoesNotExist:

        inst = False

    if inst:

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

        print instcontacts

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

        print contacts

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

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

@login_required

def add_contact(request, contact_pk):

    user = request.user

    server = False

    try:

        profile = user.get_profile()

        inst = profile.institution

    except UserProfile.DoesNotExist:

        inst = False

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

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

                                  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 form.is_valid():

            contact = form.save()

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

            instContPool.save()

            return HttpResponseRedirect(reverse("contacts"))

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

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

@login_required

def del_contact(request):

    if request.method == 'GET':

        user = request.user

        req_data = request.GET.copy()

        contact_pk = req_data['contact_pk']

        profile = user.get_profile()

        institution = profile.institution

        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

def base_response(request):

    user = request.user

    inst = []

    server = []

    services = []

    instrealms = []

    instcontacts = []

    contacts = []

    try:

        profile = user.get_profile()

        institution = profile.institution

        inst.append(institution)

        server = InstServer.objects.filter(instid=institution)

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

        instrealms = InstRealm.objects.filter(instid=institution)

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

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

    except UserProfile.DoesNotExist:

        pass

    return { 

            'inst_num': len(inst),

            'servers_num': len(server),

            'services_num': len(services),

            'realms_num': len(instrealms),

            'contacts_num': len(contacts),

        }

@login_required

def del_server(request):

    if request.method == 'GET':

        user = request.user

        req_data = request.GET.copy()

        server_pk = req_data['server_pk']

        profile = user.get_profile()

        institution = profile.institution

        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

def del_service(request):

    if request.method == 'GET':

        user = request.user

        req_data = request.GET.copy()

        service_pk = req_data['service_pk']

        profile = user.get_profile()

        institution = profile.institution

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

def geolocate(request):

    return render_to_response('front/geolocate.html',

                                  context_instance=RequestContext(request))

def closest(request):

    if request.method == 'GET':

        locs = []

        request_data = request.GET.copy()

        response_location = {}

        response_location["lat"] = request_data['lat']

        response_location["lng"] = request_data['lng']

        lat = float(request_data['lat'])

        lng = float(request_data['lng'])

        R = 6371

        distances = {}

        closestMarker = {}

        closest = -1

        doc = ET.parse(settings.KML_FILE)

        root = doc.getroot()

        r = root.getchildren()[0]

        for (counter, i) in enumerate(r.getchildren()):

            if "id" in i.keys():

                j = i.getchildren()

                pointname = j[0].text

                point = j[2].getchildren()[0].text

                pointlng, pointlat, pointele = point.split(',')

                dLat = rad(float(pointlat)-float(lat))

                dLong = rad(float(pointlng)-float(lng))

                a = math.sin(dLat/2) * math.sin(dLat/2) + math.cos(rad(lat)) * math.cos(rad(float(pointlat))) * math.sin(dLong/2) * math.sin(dLong/2) 

                c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))

                d = R * c

                distances[counter] = d

                if (closest == -1 or d < distances[closest]):

                    closest = counter

                    closestMarker = {"name": pointname, "lat": pointlat, "lng": pointlng, "text": j[1].text}

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

def instxml(request):

    ET._namespace_map["http://www.w3.org/2001/XMLSchema-instance"] = 'xsi'

    root = ET.Element("institutions")

    NS_XSI = "{http://www.w3.org/2001/XMLSchema-instance}"

    root.set(NS_XSI + "noNamespaceSchemaLocation", "institutions.xsd")

    #root.attrib["xsi:noNamespaceSchemaLocation"] = "institution.xsd"

    institutions = Institution.objects.all()

    for institution in institutions:

        try:

            inst = institution.institutiondetails

            if not inst:

                pass

        except InstitutionDetails.DoesNotExist:

            pass

        instElement = ET.SubElement(root, "institution")

        instCountry = ET.SubElement(instElement, "country")

        instCountry.text = ("%s" %inst.institution.realmid.country).upper()

        instType = ET.SubElement(instElement, "type")

        instType.text = "%s" %inst.ertype

        for realm in institution.instrealm_set.all():

            instRealm = ET.SubElement(instElement, "inst_realm")

            instRealm.text = realm.realm

        for name in inst.institution.org_name.all():

            instOrgName = ET.SubElement(instElement, "org_name")

            instOrgName.attrib["lang"] = name.lang

            instOrgName.text = u"%s" %name.name

        instAddress = ET.SubElement(instElement, "address")

        instAddrStreet = ET.SubElement(instAddress, "street")

        instAddrStreet.text = inst.address_street

        instAddrCity = ET.SubElement(instAddress, "city")

        instAddrCity.text = inst.address_city

        for contact in inst.contact.all():

            instContact = ET.SubElement(instElement, "contact")

            instContactName = ET.SubElement(instContact, "name")

            instContactName.text = "%s %s" %(contact.firstname, contact.lastname)

            instContactEmail = ET.SubElement(instContact, "email")

            instContactEmail.text = contact.email

            instContactPhone = ET.SubElement(instContact, "phone")

            instContactPhone.text = contact.phone

        for url in inst.url.all():

            instUrl = ET.SubElement(instElement, "%s_URL"%(url.urltype))

            instUrl.attrib["lang"] = url.lang

            instUrl.text = url.url

        #Let's go to Institution Service Locations

        for serviceloc in inst.institution.serviceloc_set.all():

            instLocation = ET.SubElement(instElement, "location")

            instLong = ET.SubElement(instLocation, "longitude")

            instLong.text = "%s" %serviceloc.longitude

            instLat = ET.SubElement(instLocation, "latitude")

            instLat.text = "%s" %serviceloc.latitude

            for instlocname in serviceloc.loc_name.all():

                instLocName = ET.SubElement(instLocation, "loc_name")

                instLocName.attrib["lang"] = instlocname.lang

                instLocName.text = instlocname.name

            instLocAddress = ET.SubElement(instLocation, "address")

            instLocAddrStreet = ET.SubElement(instLocAddress, "street")

            instLocAddrStreet.text = serviceloc.address_street

            instLocAddrCity = ET.SubElement(instLocAddress, "city")

            instLocAddrCity.text = serviceloc.address_city

            instLocSSID = ET.SubElement(instLocation, "SSID")

            instLocSSID.text = serviceloc.SSID

            instLocEncLevel = ET.SubElement(instLocation, "enc_level")

            instLocEncLevel.text = serviceloc.enc_level

            instLocPortRestrict = ET.SubElement(instLocation, "port_restrict")

            instLocPortRestrict.text = ("%s" %serviceloc.port_restrict).lower()

            instLocTransProxy = ET.SubElement(instLocation, "transp_proxy")

            instLocTransProxy.text = ("%s" %serviceloc.transp_proxy).lower()

            instLocIpv6 = ET.SubElement(instLocation, "IPv6")

            instLocIpv6.text = ("%s" %serviceloc.IPv6).lower()

            instLocNAT = ET.SubElement(instLocation, "NAT")

            instLocNAT.text = ("%s" %serviceloc.NAT).lower()

            instLocAP_no = ET.SubElement(instLocation, "AP_no")

            instLocAP_no.text = "%s" %int(serviceloc.AP_no)

            instLocWired = ET.SubElement(instLocation, "wired")

            instLocWired.text = ("%s" %serviceloc.wired).lower()

            for url in serviceloc.url.all():

                instLocUrl = ET.SubElement(instLocation, "%s_URL"%(url.urltype))

                instLocUrl.attrib["lang"] = url.lang

                instLocUrl.text = url.url

        instTs = ET.SubElement(instElement, "ts")

        instTs.text = "%s" %inst.ts.isoformat()

    return render_to_response("general/institution.xml", {"xml":to_xml(root)},context_instance=RequestContext(request,), mimetype="application/xml")

def realmxml(request):

    realm = Realm.objects.all()[0]

    ET._namespace_map["http://www.w3.org/2001/XMLSchema-instance"] = 'xsi'

    root = ET.Element("realms")

    NS_XSI = "{http://www.w3.org/2001/XMLSchema-instance}"

    root.set(NS_XSI + "noNamespaceSchemaLocation", "realm.xsd")

    #root.attrib["xsi:noNamespaceSchemaLocation"] = "institution.xsd"

    realmElement = ET.SubElement(root, "realm")

    realmCountry = ET.SubElement(realmElement, "country")

    realmCountry.text = realm.country

    realmStype = ET.SubElement(realmElement, "stype")

    realmStype.text = "%s" %realm.stype

    for name in realm.org_name.all():

        realmOrgName = ET.SubElement(realmElement, "org_name")

        realmOrgName.attrib["lang"] = name.lang

        realmOrgName.text = u"%s" %name.name

    realmAddress = ET.SubElement(realmElement, "address")

    realmAddrStreet = ET.SubElement(realmAddress, "street")

    realmAddrStreet.text = realm.address_street

    realmAddrCity = ET.SubElement(realmAddress, "city")

    realmAddrCity.text = realm.address_city

    for contact in realm.contact.all():

        realmContact = ET.SubElement(realmElement, "contact")

        realmContactName = ET.SubElement(realmContact, "name")

        realmContactName.text = "%s %s" %(contact.firstname, contact.lastname)

        realmContactEmail = ET.SubElement(realmContact, "email")

        realmContactEmail.text = contact.email

        realmContactPhone = ET.SubElement(realmContact, "phone")

        realmContactPhone.text = contact.phone

    for url in realm.url.all():

        realmUrl = ET.SubElement(realmElement, "%s_URL"%(url.urltype))

        realmUrl.attrib["lang"] = url.lang

        realmUrl.text = url.url

    return render_to_response("general/realm.xml", {"xml":to_xml(root)},context_instance=RequestContext(request,), mimetype="application/xml")

def realmdataxml(request):

    realm = Realm.objects.all()[0]

    ET._namespace_map["http://www.w3.org/2001/XMLSchema-instance"] = 'xsi'

    root = ET.Element("realm-data")

    NS_XSI = "{http://www.w3.org/2001/XMLSchema-instance}"

    root.set(NS_XSI + "noNamespaceSchemaLocation", "realm-data.xsd")

    return render_to_response("general/realm_data.xml", {"xml":to_xml(root)},context_instance=RequestContext(request,), mimetype="application/xml")

def to_xml(ele, encoding="UTF-8"):

    "Convert and return the XML for an *ele* (:class:`~xml.etree.ElementTree.Element`) with specified *encoding*."

    xml = ET.tostring(ele, encoding)

    return xml if xml.startswith('<?xml') else '<?xml version="1.0" encoding="%s"?>%s' % (encoding, xml)

def getInstContacts(inst):

    contacts = InstitutionContactPool.objects.filter(institution=inst)

    contact_pks = []

    for contact in contacts:

        contact_pks.append(contact.contact.pk)

    return list(set(contact_pks))

def getInstServers(inst):

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

    server_pks = []

    for server in servers:

        server_pks.append(server.pk)

    return list(set(server_pks))

def rad(x):

    return x*math.pi/180