coin/coin/isp_database/models.py

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from django.db import models
from django.core.validators import MaxValueValidator
from django.core.exceptions import ValidationError
from django.utils.translation import ugettext_lazy as _
from localflavor.generic.models import IBANField, BICField
from localflavor.fr.models import FRSIRETField

from coin.members.models import count_active_members
from coin.offers.models import count_active_subscriptions
from coin import utils

# API version, see http://db.ffdn.org/format
API_VERSION = 0.1

TECHNOLOGIES = (('ftth', _('FTTH')),
                ('dsl', _('xDSL')),
                ('wifi', _('Wi-Fi')))


class SingleInstanceMixin(object):
    """Makes sure that no more than one instance of a given model is created."""

    def clean(self):
        from django.utils.translation import ugettext as _
        model = self.__class__
        if (model.objects.count() > 0 and self.id != model.objects.get().id):
            error = _("Can only create 1 instance of {model}.")
            raise ValidationError(error.format(model=model.__name__))
        super(SingleInstanceMixin, self).clean()


class ISPInfo(SingleInstanceMixin, models.Model):
    """http://db.ffdn.org/format

    The naming convention is different from Python/django so that it
    matches exactly the format (which uses CamelCase...)
    """
    name = models.CharField(max_length=512, verbose_name=_("name"),
                            help_text=_("The ISP's name"))
    # Length required by the spec
    shortname = models.CharField(max_length=15, blank=True,
                                 verbose_name=_("short name"),
                                 help_text=_("Shorter name"))
    description = models.TextField(blank=True, verbose_name=_("description"),
                                   help_text=_("Short text describing the project"))
    logoURL = models.URLField(blank=True, verbose_name=_("logo URL"),
                              help_text=_("HTTP(S) URL of the ISP's logo"))
    website = models.URLField(blank=True, verbose_name=_("website"),
                              help_text=_('URL to the official website'))
    email = models.EmailField(max_length=254, verbose_name=_("email"),
                              help_text=_("Contact email address"))
    mainMailingList = models.EmailField(max_length=254, blank=True,
                                        verbose_name=_("main mailing list"),
                                        help_text=_("Main public mailing-list"))
    creationDate = models.DateField(blank=True, null=True,
                                    verbose_name=_("creation date"),
                                    help_text=_("Date of creation for legal structure"))
    ffdnMemberSince = models.DateField(blank=True, null=True,
                                       verbose_name=_("FFDN member since"),
                                       help_text=_("Date at wich the ISP joined the Federation"))
    # TODO: choice field
    progressStatus = models.PositiveSmallIntegerField(
        validators=[MaxValueValidator(7)],
        blank=True, null=True, verbose_name=_('progress status'),
        help_text=_("Progression status of the ISP"))
    # TODO: better model for coordinates
    latitude = models.FloatField(blank=True, null=True,
                                 verbose_name=_("latitude"),
                                 help_text=_("Coordinates of the registered "
                                 "office (latitude)"))
    longitude = models.FloatField(blank=True, null=True,
                                  verbose_name=_("longitude"),
                                  help_text=_("Coordinates of the registered "
                                  "office (longitude)"))

    # Uncomment this if you want to manage these counters by hand.
    #member_count = models.PositiveIntegerField(help_text="Number of members")
    #subscriber_count = models.PositiveIntegerField(
    #    help_text="Number of subscribers to an internet access")

    # field outside of db-ffdn format:
    administrative_email = models.EmailField(
        max_length=254, blank=True, verbose_name=_("administrative contact email"),
        help_text=_("Email address to use for administrative inquiries "
                    "(e.g. membership, personal information)"))

    support_email = models.EmailField(
        max_length=254, blank=True, verbose_name=_("support contact email"),
        help_text=_("Email address to use for technical support"))

    lists_url = models.URLField(
        verbose_name=_("mailing list server"), blank=True,
        help_text=_("URL of the mailing list server"))

    @property
    def memberCount(self):
        """Number of members"""
        return count_active_members()

    @property
    def subscriberCount(self):
        """Number of subscribers to an internet access"""
        return count_active_subscriptions()

    @property
    def version(self):
        """Version of the API"""
        return API_VERSION

    @property
    def main_chat_verbose(self):
        from django.utils.translation import ugettext as _
        m = utils.re_chat_url.match(self.chatroom_set.first().url)
        return _('{channel} on {server}').format(**(m.groupdict()))

    def get_absolute_url(self):
        return '/isp.json'

    def to_dict(self):
        data = dict()
        # These are required
        for f in ('version', 'name', 'email', 'memberCount', 'subscriberCount'):
            data[f] = getattr(self, f)

        # These are optional
        for f in ('shortname', 'description', 'logoURL', 'website',
                  'mainMailingList', 'progressStatus'):
            if getattr(self, f):
                data[f] = getattr(self, f)

        # Dates
        for d in ('creationDate', 'ffdnMemberSince'):
            if getattr(self, d):
                data[d] = getattr(self, d).isoformat()

        # Hackish for now
        if self.latitude or self.longitude:
            data['coordinates'] = { "latitude": self.latitude,
                                    "longitude": self.longitude }

        # Related objects
        data['coveredAreas'] = [c.to_dict() for c in self.coveredarea_set.all()]
        otherwebsites = self.otherwebsite_set.all()
        if otherwebsites:
            data['otherWebsites'] = { site.name: site.url for site in otherwebsites }
        chatrooms = self.chatroom_set.all()
        if chatrooms:
            data['chatrooms'] = [chatroom.url for chatroom in chatrooms]
        if hasattr(self, 'registeredoffice'):
            data['registeredOffice'] = self.registeredoffice.to_dict()

        return data

    def __unicode__(self):
        return self.name

    class Meta:
        verbose_name = _('ISP details')
        verbose_name_plural = _('ISP details')


class OtherWebsite(models.Model):
    name = models.CharField(max_length=512, verbose_name=_("name"))
    url = models.URLField(verbose_name=_("URL"))
    isp = models.ForeignKey(ISPInfo, verbose_name=_("ISP"))

    class Meta:
        verbose_name = _('other website')
        verbose_name_plural = _('other websites')


class RegisteredOffice(models.Model):
    """ http://json-schema.org/address """
    post_office_box = models.CharField(max_length=512, blank=True,
                                       verbose_name=_("post office box"))
    extended_address = models.CharField(max_length=512, blank=True,
                                        verbose_name=_("extended address"))
    street_address = models.CharField(max_length=512, blank=True,
                                      verbose_name=_("street address"))
    locality = models.CharField(max_length=512, verbose_name=_("locality"))
    region = models.CharField(max_length=512, verbose_name=_("region"))
    postal_code = models.CharField(max_length=512, blank=True,
                                   verbose_name=_("postal code"))
    country_name = models.CharField(max_length=512,
                                    verbose_name=_("country name"))
    isp = models.OneToOneField(ISPInfo, verbose_name=_("ISP"))

    # not in db.ffdn.org spec
    siret = FRSIRETField('SIRET')

    def to_dict(self):
        d = dict()
        for field in ('post_office_box', 'extended_address', 'street_address',
                      'locality', 'region', 'postal_code', 'country_name'):
            if getattr(self, field):
                key = field.replace('_', '-')
                d[key] = getattr(self, field)
        return d

    class Meta:
        verbose_name = _('registered office')
        verbose_name_plural = _('registered offices')


class ChatRoom(models.Model):
    url = models.CharField(verbose_name=_("URL"), max_length=256)
    isp = models.ForeignKey(ISPInfo, verbose_name=_("ISP"))

    class Meta:
        verbose_name = _('chat room')
        verbose_name_plural = _('chat rooms')


class CoveredArea(models.Model):
    name = models.CharField(max_length=512, verbose_name=_("name"))
    # TODO: we must allow multiple values
    technologies = models.CharField(choices=TECHNOLOGIES, max_length=16,
                                    verbose_name=_("technologies"))
    # TODO: find a geojson library
    #area =
    isp = models.ForeignKey(ISPInfo, verbose_name=_("ISP"))

    def to_dict(self):
        return {"name": self.name,
                "technologies": [self.technologies]}

    class Meta:
        verbose_name = _('covered area')
        verbose_name_plural = _('covered areas')


class BankInfo(models.Model):
    """Information about bank account and the bank itself

    This is out of the scope of db.ffdn.org spec.
    """
    isp = models.OneToOneField(ISPInfo, verbose_name=_("ISP"))
    iban = IBANField(verbose_name=_('IBAN'))
    bic = BICField(verbose_name=_('BIC'), blank=True, null=True)
    bank_name = models.CharField(verbose_name=_("bank name"), max_length=100,
                                 blank=True, null=True)
    check_order = models.CharField(verbose_name=_("check recipient"),
                                   max_length=100, blank=False, null=False,
                                   help_text=_("Recipient that must appear on "
                                               "a bank check destinated to "
                                               "the ISP"))

    class Meta:
        verbose_name = _('bank information')
        verbose_name_plural = _('banks information')