Merge remote-tracking branch 'ARN/housing'

housing/__init__.py

@@ -0,0 +1 @@
+default_app_config = 'housing.apps.HousingConfig'

housing/admin.py

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.contrib import admin
+from polymorphic.admin import PolymorphicChildModelAdmin
+
+from coin.configuration.admin import ConfigurationAdminFormMixin
+from coin.utils import delete_selected
+
+from .models import HousingConfiguration
+
+
+
+class HousingConfigurationInline(admin.StackedInline):
+    model = HousingConfiguration
+    # fk_name = 'offersubscription'
+    readonly_fields = ['configuration_ptr']
+
+
+class HousingConfigurationAdmin(ConfigurationAdminFormMixin, PolymorphicChildModelAdmin):
+    base_model = HousingConfiguration
+    list_display = ('offersubscription', 'activated',
+                    'ipv4_endpoint', 'ipv6_endpoint', 'comment')
+    list_filter = ('activated',)
+    search_fields = ('comment',
+                     # TODO: searching on member directly doesn't work
+                     'offersubscription__member__first_name',
+                     'offersubscription__member__last_name',
+                     'offersubscription__member__email')
+    actions = (delete_selected, "generate_endpoints", "generate_endpoints_v4",
+               "generate_endpoints_v6", "activate", "deactivate")
+    inline = HousingConfigurationInline
+
+    def get_readonly_fields(self, request, obj=None):
+        if obj:
+            return []
+        else:
+            return []
+
+    def set_activation(self, request, queryset, value):
+        count = 0
+        # We must update each object individually, because we want to run
+        # the save() method to update the backend.
+        for housing in queryset:
+            if housing.activated != value:
+                housing.activated = value
+                housing.full_clean()
+                housing.save()
+                count += 1
+        action = "activated" if value else "deactivated"
+        msg = "{} Housing subscription(s) {}.".format(count, action)
+        self.message_user(request, msg)
+
+    def activate(self, request, queryset):
+        self.set_activation(request, queryset, True)
+    activate.short_description = "Activate selected Housings"
+
+    def deactivate(self, request, queryset):
+        self.set_activation(request, queryset, False)
+    deactivate.short_description = "Deactivate selected Housings"
+
+    def generate_endpoints_generic(self, request, queryset, v4=True, v6=True):
+        count = 0
+        for housing in queryset:
+            if housing.generate_endpoints(v4, v6):
+                housing.full_clean()
+                housing.save()
+                count += 1
+        msg = "{} Housing subscription(s) updated.".format(count)
+        self.message_user(request, msg)
+
+    def generate_endpoints(self, request, queryset):
+        self.generate_endpoints_generic(request, queryset)
+    generate_endpoints.short_description = "Generate IPv4 and IPv6 endpoints"
+
+    def generate_endpoints_v4(self, request, queryset):
+        self.generate_endpoints_generic(request, queryset, v6=False)
+    generate_endpoints_v4.short_description = "Generate IPv4 endpoints"
+
+    def generate_endpoints_v6(self, request, queryset):
+        self.generate_endpoints_generic(request, queryset, v4=False)
+    generate_endpoints_v6.short_description = "Generate IPv6 endpoints"
+
+admin.site.register(HousingConfiguration, HousingConfigurationAdmin)

housing/apps.py

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.apps import AppConfig
+import coin.apps
+
+from . import urls
+
+
+class HousingConfig(AppConfig, coin.apps.AppURLs):
+    name = 'housing'
+    verbose_name = "Gestion d'accès Housing"
+
+    exported_urlpatterns = [('housing', urls.urlpatterns)]

housing/migrations/0001_initial.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+import netfields.fields
+import coin.validation
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('configuration', '0004_auto_20161015_1837'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='HousingConfiguration',
+            fields=[
+                ('configuration_ptr', models.OneToOneField(parent_link=True, auto_created=True, primary_key=True, serialize=False, to='configuration.Configuration')),
+                ('activated', models.BooleanField(default=False, verbose_name='activ\xe9')),
+                ('ipv4_endpoint', netfields.fields.InetAddressField(validators=[coin.validation.validate_v4], max_length=39, blank=True, help_text='Adresse IPv4 utilis\xe9e par d\xe9faut sur le Housing', null=True, verbose_name='IPv4')),
+                ('ipv6_endpoint', netfields.fields.InetAddressField(validators=[coin.validation.validate_v6], max_length=39, blank=True, help_text='Adresse IPv6 utilis\xe9e par d\xe9faut sur le Housing', null=True, verbose_name='IPv6')),
+                ('vlan', models.IntegerField(null=True, verbose_name='vlan id')),
+            ],
+            options={
+                'verbose_name': 'Housing',
+            },
+            bases=('configuration.configuration',),
+        ),
+    ]

housing/models.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models
+from polymorphic import PolymorphicModel
+from django.core.exceptions import ValidationError
+from django.core.urlresolvers import reverse
+from netfields import InetAddressField, NetManager
+
+from coin.configuration.models import Configuration
+# from coin.offers.backends import ValidateBackendType
+from coin import validation
+
+
+class HousingConfiguration(Configuration):
+    url_namespace = "housing"
+    activated = models.BooleanField(default=False, verbose_name='activé')
+    ipv4_endpoint = InetAddressField(validators=[validation.validate_v4],
+                                     verbose_name="IPv4", blank=True, null=True,
+                                     help_text="Adresse IPv4 utilisée par "
+                                     "défaut sur le Housing")
+    ipv6_endpoint = InetAddressField(validators=[validation.validate_v6],
+                                     verbose_name="IPv6", blank=True, null=True,
+                                     help_text="Adresse IPv6 utilisée par "
+                                     "défaut sur le Housing")
+    vlan = models.IntegerField(verbose_name="vlan id", null=True)
+    objects = NetManager()
+
+    def get_absolute_url(self):
+        return reverse('housing:details', args=[str(self.pk)])
+
+    # This method is part of the general configuration interface.
+    def subnet_event(self):
+        self.check_endpoints(delete=True)
+        # We potentially changed the endpoints, so we need to save.  Also,
+        # saving will update the subnets in the LDAP backend.
+        self.full_clean()
+        self.save()
+
+    def get_subnets(self, version):
+        subnets = self.ip_subnet.all()
+        return [subnet for subnet in subnets if subnet.inet.version == version]
+
+    def generate_endpoints(self, v4=True, v6=True):
+        """Generate IP endpoints in one of the attributed IP subnets.  If there is
+        no available subnet for a given address family, then no endpoint
+        is generated for this address family.  If there already is an
+        endpoint, do nothing.
+
+        Returns True if an endpoint was generated.
+
+        TODO: this should be factored for other technologies (DSL, etc)
+
+        """
+        subnets = self.ip_subnet.all()
+        updated = False
+        if v4 and self.ipv4_endpoint is None:
+            subnets_v4 = [s for s in subnets if s.inet.version == 4]
+            if len(subnets_v4) > 0:
+                self.ipv4_endpoint = subnets_v4[0].inet.ip
+                updated = True
+        if v6 and self.ipv6_endpoint is None:
+            subnets_v6 = [s for s in subnets if s.inet.version == 6]
+            if len(subnets_v6) > 0:
+                # With v6, we choose the second host of the subnet (cafe::1)
+                gen = subnets_v6[0].inet.iter_hosts()
+                gen.next()
+                self.ipv6_endpoint = gen.next()
+                updated = True
+        return updated
+
+    def check_endpoints(self, delete=False):
+        """Check that the IP endpoints are included in one of the attributed IP
+        subnets.
+
+        If [delete] is True, then simply delete the faulty endpoints
+        instead of raising an exception.
+        """
+        error = "L'IP {} n'est pas dans un réseau attribué."
+        subnets = self.ip_subnet.all()
+        is_faulty = lambda endpoint : endpoint and not any([endpoint in subnet.inet for subnet in subnets])
+        if is_faulty(self.ipv4_endpoint):
+            if delete:
+                self.ipv4_endpoint = None
+            else:
+                raise ValidationError(error.format(self.ipv4_endpoint))
+        if is_faulty(self.ipv6_endpoint):
+            if delete:
+                self.ipv6_endpoint = None
+            else:
+                raise ValidationError(error.format(self.ipv6_endpoint))
+
+    def clean(self):
+        # If saving for the first time and IP endpoints are not specified,
+        # generate them automatically.
+        if self.pk is None:
+            self.generate_endpoints()
+        self.check_endpoints()
+
+    def __unicode__(self):
+        return 'Housing ' #+ self.login
+
+    class Meta:
+        verbose_name = 'Housing'
+

housing/templates/housing/housing.html

@@ -0,0 +1,40 @@
+{% extends "base.html" %}
+
+{% load subnets %}
+
+{% block content %}
+<div class="row">
+    <h2>Configuration du Housing</h2>
+    {% for message in messages %}
+        <div class="message eat-up{% if message.tags %} {{ message.tags }}{% endif %}">
+            {{ message }}
+        </div>
+    {% endfor %}
+    <div class="large-12 columns">
+        <div class="panel">
+            <h3>Adresses IP</h3>
+            <table class="full-width">
+                <tr class="flatfield">
+                    <td class="center"><span class="label">VLAN ID</span></td>
+                    <td>{{ object.vlan }}</td>
+                </tr>
+                <tr class="flatfield">
+                    <td class="center"><span class="label">IPv4</span></td>
+                    <td>{{ object.ipv4_endpoint }}</td>
+                </tr>
+                <tr class="flatfield">
+                    <td class="center"><span class="label">IPv6</span></td>
+                    <td>{{ object.ipv6_endpoint }}</td>
+                </tr>
+                <tr>
+                    <td class="center"><span class="label">Sous-réseaux</span></td>
+                    <td>
+                        {% for subnet in object.ip_subnet.all %}{{ subnet|prettify }}<br/>{% endfor %}
+                    </td>
+                </tr>
+            </table>
+        </div>
+    </div>
+</div>
+
+{% endblock %}

housing/tests.py

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from unittest import skipUnless
+
+from django.test import TestCase
+from django.conf import settings
+
+from coin.offers.models import Offer, OfferSubscription
+from coin.resources.models import IPPool, IPSubnet
+from coin.members.models import Member
+from coin.members.tests import MemberTestsUtils
+
+from .models import HousingConfiguration
+
+USING_POSTGRES = (settings.DATABASES['default']['ENGINE']
+                  ==
+                  'django.db.backends.postgresql_psycopg2')
+
+class HousingTestCase(TestCase):
+    fixtures = ['example_pools.json', 'offers.json']
+
+    def setUp(self):
+        self.v6_pool = IPPool.objects.get(default_subnetsize=56)
+        self.v4_pool = IPPool.objects.get(default_subnetsize=32)
+        self.offer = Offer.objects.filter(configuration_type="HousingConfiguration")[0]
+
+        # Create a member.
+        cn = MemberTestsUtils.get_random_username()
+        self.member = Member.objects.create(first_name=u"Toto",
+                                            last_name=u"L'artichaut",
+                                            username=cn)
+
+        # Create a new Housing with subnets.
+        # We need Django to call clean() so that magic happens.
+        abo = OfferSubscription(offer=self.offer, member=self.member)
+        abo.full_clean()
+        abo.save()
+        housing = HousingConfiguration(offersubscription=abo)
+        housing.full_clean()
+        housing.save()
+        v6 = IPSubnet(ip_pool=self.v6_pool, configuration=housing)
+        v6.full_clean()
+        v6.save()
+        v4 = IPSubnet(ip_pool=self.v4_pool, configuration=housing)
+        v4.full_clean()
+        v4.save()
+
+        # Create additional Housing, they should automatically be attributed a
+        # new login.
+        for i in range(5):
+            abo = OfferSubscription(offer=self.offer, member=self.member)
+            abo.full_clean()
+            abo.save()
+            housing = HousingConfiguration(offersubscription=abo)
+            housing.full_clean()
+            housing.save()
+
+    def tearDown(self):
+        """Properly clean up objects, so that they don't stay in LDAP"""
+        for housing in HousingConfiguration.objects.all():
+            housing.delete()
+        Member.objects.get().delete()
+
+    @skipUnless(USING_POSTGRES, "Using a postgresql-only field")
+    def test_has_ipv4_endpoint(self):
+        housing = HousingConfiguration.objects.all()[0]
+        self.assertIsNotNone(housing.ipv4_endpoint)
+
+    @skipUnless(USING_POSTGRES, "Using a postgresql-only field")
+    def test_has_correct_ipv4_endpoint(self):
+        """If there is not endpoint, we consider it to be correct."""
+        housing = HousingConfiguration.objects.all()[0]
+        if housing.ipv4_endpoint is not None:
+            subnet = housing.ip_subnet.get(ip_pool=self.v4_pool)
+            self.assertIn(housing.ipv4_endpoint, subnet.inet)
+
+    @skipUnless(USING_POSTGRES, "Using a postgresql-only field")
+    def test_has_ipv6_endpoint(self):
+        housing = HousingConfiguration.objects.all()[0]
+        self.assertIsNotNone(housing.ipv6_endpoint)
+
+    @skipUnless(USING_POSTGRES, "Using a postgresql-only field")
+    def test_has_correct_ipv6_endpoint(self):
+        """If there is not endpoint, we consider it to be correct."""
+        housing = HousingConfiguration.objects.all()[0]
+        if housing.ipv6_endpoint is not None:
+            subnet = housing.ip_subnet.get(ip_pool=self.v6_pool)
+            self.assertIn(housing.ipv6_endpoint, subnet.inet)
+
+    @skipUnless(USING_POSTGRES, "Using a postgresql-only field")
+    def test_change_v4subnet_is_housing_endpoint_correct(self):
+        housing = HousingConfiguration.objects.all()[0]
+        subnet = housing.ip_subnet.get(ip_pool=self.v4_pool)
+        subnet.inet = "192.168.42.42/31"
+        subnet.full_clean()
+        subnet.save()
+        self.test_has_correct_ipv4_endpoint()
+
+    @skipUnless(USING_POSTGRES, "Using a postgresql-only field")
+    def test_change_v6subnet_is_housing_endpoint_correct(self):
+        housing = HousingConfiguration.objects.all()[0]
+        subnet = housing.ip_subnet.get(ip_pool=self.v6_pool)
+        subnet.inet = "2001:db8:4242:4200::/56"
+        subnet.full_clean()
+        subnet.save()
+        self.test_has_correct_ipv6_endpoint()
+
+    def test_automatic_login(self):
+        housing = HousingConfiguration.objects.all()[0]
+        expected_login = housing.offersubscription.member.username + "-housing1"
+        self.assertEqual(housing.login, expected_login)
+
+    def test_has_multiple_housing(self):
+        housings = HousingConfiguration.objects.all()
+        self.assertEqual(len(housings), 6)

housing/urls.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.conf.urls import patterns, url
+
+from .views import HousingView
+
+urlpatterns = patterns(
+    '',
+    # This is part of the generic configuration interface (the "name" is
+    # the same as the "backend_name" of the model).
+    url(r'^(?P<pk>\d+)$', HousingView.as_view(template_name="housing/housing.html"), name="details"),
+)

housing/views.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.shortcuts import get_object_or_404
+from django.views.generic.edit import UpdateView
+from django.conf import settings
+from django.contrib.messages.views import SuccessMessageMixin
+from django.contrib.auth.decorators import login_required
+from django.utils.decorators import method_decorator
+
+from coin.members.models import Member
+
+from .models import HousingConfiguration
+
+
+class HousingView(SuccessMessageMixin, UpdateView):
+    model = HousingConfiguration
+    fields = ['ipv4_endpoint', 'ipv6_endpoint', 'comment']
+    success_message = "Configuration enregistrée avec succès !"
+
+    @method_decorator(login_required)
+    def dispatch(self, *args, **kwargs):
+        return super(HousingView, self).dispatch(*args, **kwargs)
+
+    def get_form(self, form_class=None):
+        return None
+
+    def get_object(self):
+        if self.request.user.is_superuser:
+            return get_object_or_404(HousingConfiguration, pk=self.kwargs.get("pk"))
+        # For normal users, ensure the Housing belongs to them.
+        return get_object_or_404(HousingConfiguration, pk=self.kwargs.get("pk"),
+                                 offersubscription__member=self.request.user)
+

vpn/migrations/0003_merge.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('vpn', '0002_auto_20170802_2021'),
+        ('vpn', '0002_vpnconfiguration_crypto_link'),
+    ]
+
+    operations = [
+    ]