DjNRO

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

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

'''

TODO main description

'''

from django.db import models

from django.utils.translation import ugettext as _

from django.contrib.contenttypes.models import ContentType

from django.contrib.contenttypes import generic

LANGS = (

        ('en', 'English' ),

        ('el', 'Ελληνικά'),

    )

ERTYPES = (

        (1, 'IdP only' ),

        (2, 'SP only'),

        (3, 'IdP and SP'),

    )

RADPROTOS = (

        ('radius', 'traditional RADIUS over UDP' ),

        ('radius-tcp', 'RADIUS over TCP (RFC6613)'),

        ('radius-tls', 'RADIUS over TLS (RFC6614)'),

        ('radius-dtls', 'RADIUS over datagram TLS (RESERVED)'),

    )

class Name_i18n(models.Model):

    '''

    Name in a particular language

    '''

    name = models.CharField(max_length=80)

    lang = models.CharField(max_length=5, choices=LANGS)

    content_type = models.ForeignKey(ContentType, blank=True, null=True)

    object_id = models.PositiveIntegerField(blank=True, null=True)

    content_object = generic.GenericForeignKey('content_type', 'object_id')

    def __unicode__(self):

        return self.name

class Contact(models.Model):

    '''

    Contact

    '''

    firstname = models.CharField(max_length=80, db_column='contact_firstname')

    lastname = models.CharField(max_length=80, db_column='contact_lastname')

    email = models.CharField(max_length=80, db_column='contact_email')

    phone = models.CharField(max_length=80, db_column='contact_phone')

    def __unicode__(self):

        return '%s %s <%s> (%s)' % (self.firstname, self.lastname, self.email, self.phone)

class InstitutionContactPool(models.Model):

    contact = models.OneToOneField(Contact)

    institution = models.ForeignKey("Institution")

    def __unicode__(self):

        return u"%s:%s" %(self.contact, self.institution)

class URL_i18n(models.Model):

    '''

    URL of a particular type in a particular language

    '''

    URLTYPES = (

                ('info', 'Info' ),

                ('policy', 'Policy'),

               )

    url = models.CharField(max_length=180, db_column='URL')

    lang = models.CharField(max_length=5, choices=LANGS)

    urltype = models.CharField(max_length=10, choices=URLTYPES, db_column='type')

    content_type = models.ForeignKey(ContentType, blank=True, null=True)

    object_id = models.PositiveIntegerField(blank=True, null=True)

    content_object = generic.GenericForeignKey('content_type', 'object_id')

    def __unicode__(self):

        return self.url

class InstRealm(models.Model):

    '''

    Realm of an IdP Institution

    '''

    # accept if instid.ertype: 1 (idp) or 3 (idpsp)

    realm = models.CharField(max_length=160)

    instid = models.ForeignKey("Institution")

    proxyto = models.ManyToManyField("InstServer")

    def __unicode__(self):

        return 'Realm: %s' % self.realm

    def get_servers(self):

        return ",".join(["%s"%x for x in self.proxyto.all()])

class InstServer(models.Model):

    '''

    Server of an Institution

    '''

    instid = models.ForeignKey("Institution")

    ertype = models.PositiveIntegerField(max_length=1, choices=ERTYPES, db_column='type')

    # ertype:

    # 1: accept if instid.ertype: 1 (idp) or 3 (idpsp)

    # 2: accept if instid.ertype: 2 (sp) or 3 (idpsp)

    # 3: accept if instid.ertype: 3 (idpsp)

    # hostname/ipaddr or descriptive label of server 

    name = models.CharField(max_length=80, help_text="Descriptive label",  null=True, blank=True) # ** (acts like a label)

    # hostname/ipaddr of server, overrides name

    host = models.CharField(max_length=80, help_text="IP address of FQDN hostname") # Handling with FQDN parser or ipaddr (google lib) * !!! Add help text to render it in template (mandatory, unique)

    #TODO: Add description field or label field

    # accept if type: 1 (idp) or 3 (idpsp) (for the folowing 4 fields)

    port = models.PositiveIntegerField(max_length=5, null=True, blank=True) # TODO: Also ignore while exporting XML

    acct_port = models.PositiveIntegerField(max_length=5, null=True, blank=True)

    timeout = models.PositiveIntegerField(max_length=2, null=True, blank=True)

    retry = models.PositiveIntegerField(max_length=2, null=True, blank=True)

    status_server = models.BooleanField()

    secret = models.CharField(max_length=16)

    proto = models.CharField(max_length=12, choices=RADPROTOS)

    ts = models.DateTimeField(auto_now=True)

    def __unicode__(self):

        return _('Server: %(servername)s, Type: %(ertype)s') % {

        # but name is many-to-many from institution

            #'inst': self.instid,

            'servername': self.name,

        # the human-readable name would be nice here

            'ertype': self.ertype,

            }

    def get_name(self):

        if self.name:

            return self.name

        return self.host

class InstRealmMon(models.Model):

    '''

    Realm of an IdP Institution to be monitored

    '''

    MONTYPES = (

                ('local', 'Institution provides account for the NRO to monitor the realm' ),

                ('proxyback', 'Institution proxies the realm back to the NRO'),

               )

    instid = models.ForeignKey("Institution")

    realm = models.CharField(max_length=20)

    mon_type = models.CharField(max_length=8, choices=MONTYPES)

    def __unicode__(self):

        return _('Institution: %(inst)s, Monitored Realm: %(monrealm)s, Monitoring Type: %(montype)s') % {

        # but name is many-to-many from institution

            'inst': self.instid.name,

            'monrealm': self.realm,

            'montype': self.mon_type,

            }

class MonProxybackClient(models.Model):

    '''

    Server of an Institution that will be proxying back requests for a monitored realm

    '''

    instrealmmonid = models.ForeignKey("InstRealmMon")

    # hostname/ipaddr or descriptive label of server

    name = models.CharField(max_length=80)

    # hostname/ipaddr of server, overrides name

    host = models.CharField(max_length=80)

    status_server = models.BooleanField()

    secret = models.CharField(max_length=16)

    proto = models.CharField(max_length=12, choices=RADPROTOS)

    ts = models.DateTimeField(auto_now=True)

    def __unicode__(self):

        return _('Institution: %(inst)s, Monitored Realm: %(monrealm)s, Proxyback Client: %(servername)s') % {

        # but name is many-to-many from institution

            'inst': self.instid.name,

            'monrealm': self.instrealmmonid.realm,

            'servername': self.name,

            }

class MonLocalEAPOLData(models.Model):

    '''

    EAPOL data for an old-style monitored realm

    '''

    EAPTYPES = (

                ('PEAP', 'EAP-PEAP' ),

                ('TTLS', 'EAP-TTLS'),

                ('TLS', 'EAP-TLS'),

               )

    EAP2TYPES = (

                ('PAP', 'PAP' ),

                ('CHAP', 'CHAP'),

                ('MS-CHAPv2', 'MS-CHAPv2'),

               )

    MONRESPTYPES = (

                ('accept', 'Access-Accept expected' ),

                ('reject', 'Access-Reject expected'),

                ('both', 'RESERVED'),

               )

    instrealmmonid = models.ForeignKey("InstRealmMon")

    eap_method = models.CharField(max_length=16, choices=EAPTYPES)

    phase2 = models.CharField(max_length=16, choices=EAP2TYPES)

    # only local-part, no realm

    username = models.CharField(max_length=24)

    passwp = models.CharField(max_length=24, db_column='pass')

    cert = models.CharField(max_length=32)

    exp_response = models.CharField(max_length=6, choices=MONRESPTYPES)

    def __unicode__(self):

        return _('Institution: %(inst)s, Monitored Realm: %(monrealm)s, EAP Method: %(eapmethod)s, Phase 2: %(phase2)s, Username: %(username)s') % {

        # but name is many-to-many from institution

            'inst': self.instid.name,

            'monrealm': self.instrealmmonid.realm,

            'eapmethod': self.eap_method,

            'phase2': self.phase2,

            'username': self.username,

            }

class ServiceLoc(models.Model):

    '''

    Service Location of an SP/IdPSP Institution

    '''

    ENCTYPES = (

                ('WPA/TKIP', 'WPA-TKIP' ),

                ('WPA/AES', 'WPA-AES'),

                ('WPA2/TKIP', 'WPA2-TKIP'),

                ('WPA2/AES', 'WPA2-AES'),

               )

    # accept if institutionid.ertype: 2 (sp) or 3 (idpsp) 

    institutionid = models.ForeignKey("Institution")

    longitude = models.DecimalField(max_digits=8, decimal_places=6)

    latitude = models.DecimalField(max_digits=8, decimal_places=6)

    # TODO: multiple names can be specified [...] name in English is required

    loc_name = generic.GenericRelation(Name_i18n)

    address_street = models.CharField(max_length=96)

    address_city = models.CharField(max_length=64)

    contact = models.ManyToManyField(Contact)

    SSID = models.CharField(max_length=16)

    enc_level = models.CharField(max_length=10, choices=ENCTYPES)

    port_restrict = models.BooleanField()

    transp_proxy = models.BooleanField()

    IPv6 = models.BooleanField()

    NAT = models.BooleanField()

    AP_no = models.PositiveIntegerField(max_length=3)

    wired = models.BooleanField()

    # only urltype = 'info' should be accepted here

    url = generic.GenericRelation(URL_i18n, blank=True, null=True)

    ts = models.DateTimeField(auto_now=True)

    def __unicode__(self):

        return _('Institution: %(inst)s, Service Location: %(locname)s') % {

        # but name is many-to-many from institution

            'inst': self.institutionid,

        # but locname is many-to-many

            'locname': self.loc_name,

            }

    def get_name(self, lang=None):

        name = ', '.join([i.name for i in self.loc_name.all()])

        if not lang:

            return name

        else:

            try:

                name = self.loc_name.get(lang=lang)

                return name

            except Exception as e:

                return name

class Institution(models.Model):

    '''

    Institution

    '''

    realmid = models.ForeignKey("Realm")

    org_name = generic.GenericRelation(Name_i18n)

    ertype = models.PositiveIntegerField(max_length=1, choices=ERTYPES, db_column='type')

    def __unicode__(self):

        return "%s" % ', '.join([i.name for i in self.org_name.all()])

    def get_name(self, lang=None):

        name = ', '.join([i.name for i in self.org_name.all()])

        if not lang:

            return name

        else:

            try:

                name = self.org_name.get(lang=lang)

                return name

            except Exception as e:

                return name

class InstitutionDetails(models.Model):

    '''

    Institution Details

    '''

    institution = models.OneToOneField(Institution)

    # TODO: multiple names can be specified [...] name in English is required

    address_street = models.CharField(max_length=96)

    address_city = models.CharField(max_length=64)

    contact = models.ManyToManyField(Contact)

    url = generic.GenericRelation(URL_i18n)

    # accept if ertype: 2 (sp) or 3 (idpsp) (Applies to the following field)

    oper_name = models.CharField(max_length=24, null=True, blank=True)

    # accept if ertype: 1 (idp) or 3 (idpsp) (Applies to the following field)

    number_user = models.PositiveIntegerField(max_length=6, null=True, blank=True)

    number_id = models.PositiveIntegerField(max_length=6)

    ts = models.DateTimeField(auto_now=True)

    def __unicode__(self):

        return _('Institution: %(inst)s, Type: %(ertype)s') % {

        # but name is many-to-many from institution

            'inst': ', '.join([i.name for i in self.institution.org_name.all()]),

            'ertype': self.institution.ertype,

            }

class Realm(models.Model):

    '''

    Realm

    '''

    COUNTRIES = (

                ('gr', 'Greece' ),

               )

    country = models.CharField(max_length=2, choices=COUNTRIES)

    stype = models.PositiveIntegerField(max_length=1, default=0, editable=False)

    # TODO: multiple names can be specified [...] name in English is required

    org_name = generic.GenericRelation(Name_i18n)

    address_street = models.CharField(max_length=32)

    address_city = models.CharField(max_length=24)

    contact = models.ManyToManyField(Contact)

    url = generic.GenericRelation(URL_i18n)

    ts = models.DateTimeField(auto_now=True)

    def __unicode__(self):

        return _('Country: %(country)s, NRO: %(orgname)s') % {

        # but name is many-to-many from institution

            'orgname': ', '.join([i.name for i in self.org_name.all()]),

            'country': self.country,

            }

# TODO: this represents a *database view* "realm_data", find a better way to write it

class RealmData(models.Model):

    '''

    Realm statistics

    '''

    realmid = models.OneToOneField(Realm)

    # db: select count(institution.id) as number_inst from institution, realm where institution.realmid == realm.realmid

    number_inst = models.PositiveIntegerField(max_length=5, editable=False)

    # db: select sum(institution.number_user) as number_user from institution, realm where institution.realmid == realm.realmid

    number_user = models.PositiveIntegerField(max_length=9, editable=False)

    # db: select sum(institution.number_id) as number_id from institution, realm where institution.realmid == realm.realmid

    number_id = models.PositiveIntegerField(max_length=9, editable=False)

    # db: select count(institution.id) as number_IdP from institution, realm where institution.realmid == realm.realmid and institution.type == 1

    number_IdP = models.PositiveIntegerField(max_length=5, editable=False)

    # db: select count(institution.id) as number_SP from institution, realm where institution.realmid == realm.realmid and institution.type == 2

    number_SP = models.PositiveIntegerField(max_length=5, editable=False)

    # db: select count(institution.id) as number_IdPSP from institution, realm where institution.realmid == realm.realmid and institution.type == 3

    number_IdPSP = models.PositiveIntegerField(max_length=5, editable=False)

    # db: select greatest(max(realm.ts), max(institution.ts)) as ts from institution, realm where institution.realmid == realm.realmid

    ts = models.DateTimeField(editable=False)

    def __unicode__(self):

        return _('Country: %(country)s, NRO: %(orgname)s, Institutions: %(inst)s, IdPs: %(idp)s, SPs: %(sp)s, IdPSPs: %(idpsp)s, Users: %(numuser)s, Identities: %(numid)s') % {

        # but name is many-to-many from institution

            'orgname': self.org_name,

            'country': self.country,

            'inst': self.number_inst,

            'idp': self.number_IdP,

            'sp': self.number_SP,

            'idpsp': self.number_IdPSP,

            'numuser': self.number_user,

            'numid': self.number_id,

            }