coin/billing/admin.py

@@ -65,8 +65,8 @@ class InvoiceDetailInlineReadOnly(admin.StackedInline):
         return False
 
     def get_readonly_fields(self, request, obj=None):
-        if self.declared_fieldsets:
-            result = flatten_fieldsets(self.declared_fieldsets)
+        if self.get_fieldsets(request, obj):
+            result = flatten_fieldsets(self.get_fieldsets(request, obj))
         else:
             result = list(set(
                 [field.name for field in self.opts.local_fields] +
@@ -122,8 +122,8 @@ class InvoiceAdmin(admin.ModelAdmin):
         Si la facture est validée, passe tous les champs en readonly
         """
         if obj and obj.validated:
-            if self.declared_fieldsets:
-                return flatten_fieldsets(self.declared_fieldsets)
+            if self.get_fieldsets(request, obj):
+                return flatten_fieldsets(self.get_fieldsets(request, obj))
             else:
                 return list(set(
                     [field.name for field in self.opts.local_fields] +
@@ -233,7 +233,7 @@ class PaymentAdmin(admin.ModelAdmin):
         # If payment already started to be allocated or already have a member
         if obj and (obj.amount_already_allocated() != 0 or obj.member != None):
             # All fields are readonly
-            return flatten_fieldsets(self.declared_fieldsets)
+            return flatten_fieldsets(self.get_fieldsets(request, obj))
         else:
             return self.readonly_fields
 

coin/billing/templates/admin/billing/invoice/change_form.html

@@ -1,5 +1,4 @@
 {% extends "admin/change_form.html" %}
-{% load url from future %}
 {% block object-tools-items %}
     {% if not original.validated %}
         <li><a href="{% url 'admin:invoice_validate' id=object_id %}">Valider la facture</a></li>

coin/members/templates/admin/members/member/change_form.html

@@ -1,6 +1,8 @@
 {% extends "admin/change_form.html" %}
-{% load url from future %}
 {% block object-tools-items %}
-    <li><a href="{% url 'admin:send_welcome_email' id=object_id %}" onclick="return confirm('Voulez-vous vraiment envoyer le courriel de confirmation a ce membre ?');">Envoyer le courriel de bienvenue</a></li>
+    <li><a href="{% url 'admin:send_welcome_email' id=object_id %}" onclick="return confirm('Voulez-vous vraiment envoyer le courriel de confirmation à ce membre ?');">Envoyer le courriel de bienvenue</a></li>
+    {% if request.user.is_superuser %}
+    <li><a href="{% url 'hijack:login_with_id' user_id=object_id %}">Endosser temporairement cette identité</a></li>
+    {% endif %}
     {{ block.super }}
 {% endblock %}

coin/members/tests.py

@@ -15,6 +15,7 @@ from django.conf import settings
 from django.test import TestCase, Client
 from django.core import mail, management
 from django.core.exceptions import ValidationError
+from django.core.urlresolvers import reverse
 
 from coin.members.models import Member, MembershipFee, LdapUser
 from coin.validation import chatroom_url_validator
@@ -424,7 +425,9 @@ class MemberAdminTests(TestCase):
                         last_name=last_name, username=username)
         member.save()
 
-        edit_page = self.client.get('/admin/members/member/%i/' % member.id)
+        edit_page = self.client.get(reverse('admin:members_member_change',
+                                            args=(member.id,)))
+
         self.assertNotContains(edit_page,
                                '''<input id="id_username" />''',
                                html=True)
@@ -533,12 +536,13 @@ class MembershipFeeTests(TestCase):
 
         # If there is no start_date clean_fields() should raise an
         # error but not clean().
-        membershipfee = MembershipFee(member=member)
+        membershipfee = MembershipFee(member=member, amount=15)
         self.assertRaises(ValidationError, membershipfee.clean_fields)
         self.assertIsNone(membershipfee.clean())
 
         # If there is a start_date, everything is fine.
-        membershipfee = MembershipFee(member=member, start_date=date.today())
+        membershipfee = MembershipFee(member=member, amount=15,
+                start_date=date.today())
         self.assertIsNone(membershipfee.clean_fields())
         self.assertIsNone(membershipfee.clean())
 

coin/offers/fixtures/offers.json

@@ -53,5 +53,16 @@
             "period_fees": "28.00",
             "configuration_type": ""
         }
+    },
+    {
+        "pk": 6,
+        "model": "offers.offer",
+        "fields": {
+            "billing_period": 1,
+            "name": "VPS 1Go",
+            "initial_fees": "0.00",
+            "period_fees": "8.00",
+            "configuration_type": "VPSConfiguration"
+        }
     }
 ]

coin/settings_base.py

@@ -166,6 +166,9 @@ INSTALLED_APPS = (
     # 'south',
     'autocomplete_light', #Automagic autocomplete foreingkey form component
     'activelink', #Detect if a link match actual page
+    'compat',
+    'hijack',
+
     'coin',
     'coin.members',
     'coin.offers',
@@ -240,6 +243,15 @@ AUTHENTICATION_BACKENDS = (
 
 TEST_RUNNER = 'django.test.runner.DiscoverRunner'
 
+# Where admins are redirected to after hijacking a user
+HIJACK_LOGIN_REDIRECT_URL = '/'
+
+# Where admins are redirected to after releasing a user
+HIJACK_LOGOUT_REDIRECT_URL = '/admin/members/member/'
+
+# Needed for link in admin
+HIJACK_ALLOW_GET_REQUESTS = True
+
 GRAPHITE_SERVER = "http://localhost"
 
 # Configuration for outgoing emails
@@ -299,18 +311,8 @@ FEEDS = (
 #    ('isp', 'http://isp.example.com/feed/', 3),
 )
 
-# Account registration
-# Allow visitor to join the association by register on COIN
-REGISTRATION_OPEN = False
+# Allow user to edit their VPS Info
+MEMBER_CAN_EDIT_VPS_CONF = True
 
-# All account with unvalidated email will be deleted after X days
-ACCOUNT_ACTIVATION_DAYS = 7
-
-# Member can edit their own data
-MEMBER_CAN_EDIT_PROFILE = False
-
-# Allows to deactivate displays and calculations of balances.
-HANDLE_BALANCE = False
-
-# Add subscription comments in invoice items
-INVOICES_INCLUDE_CONFIG_COMMENTS = True
+# Allow user to edit their VPN Info
+MEMBER_CAN_EDIT_VPN_CONF = True

coin/templates/admin/base_site.html

@@ -1,8 +1,10 @@
 {% extends "admin/base.html" %}
 {% load i18n %}
 {% load staticfiles %}
+{% load hijack_tags %}
 
 {% block extrahead %}
+    <link rel="stylesheet" type="text/css" href="{% static 'hijack/hijack-styles.css' %}" />
     <script src="{% static "js/vendor/jquery.js" %}" type="text/javascript"></script>
     {% include 'autocomplete_light/static.html' %}
 {% endblock %}
@@ -10,6 +12,7 @@
 {% block title %}COIN ☺ Admin{% endblock %}
 
 {% block branding %}
+{% hijack_notification %}
 <h1 id="site-name">Administration de COIN</h1>
 {% endblock %}
 

coin/templates/base.html

@@ -1,5 +1,6 @@
 <!doctype html>
 {% load staticfiles %}
+{% load hijack_tags %}
 <html class="no-js" lang="en">
 <head>
     <meta charset="utf-8" />
@@ -9,12 +10,14 @@
     <link rel="stylesheet" href="{% static "css/font-awesome.min.css"%}" />
     <link rel="stylesheet" href="{% static "css/local.css" %}" />
     <link rel="stylesheet" href="{% static "css/offcanvas.css" %}">
+    <link rel="stylesheet" type="text/css" href="{% static 'hijack/hijack-styles.css' %}" />
     {% block extra_css %}{% endblock %}
     <script src="{% static "js/vendor/modernizr.js" %}"></script>
     <link rel="icon" type="image/png" href="{% static "img/coinitem.png" %}"/>
     <link rel="icon" type="image/x-icon" href="{% static "img/favicon.ico" %}" />
 </head>
 <body>
+{% hijack_notification %}
 <div class="off-canvas-wrap" data-offcanvas>
     <div class="inner-wrap">
 

coin/urls.py

@@ -39,6 +39,7 @@ urlpatterns = patterns(
     url(r'^subscription/', include('coin.offers.urls', namespace='subscription')),
 
     url(r'^admin/', include(admin.site.urls)),
+    url(r'^hijack/', include('hijack.urls', namespace='hijack')),
 
     # url(r'^admin/doc/', include('django.contrib.admindocs.urls')),
 

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,12 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import unicode_literals
+from django.apps import AppConfig
+import coin.apps
+
+
+class HousingConfig(AppConfig, coin.apps.AppURLs):
+    name = 'housing'
+    verbose_name = "Gestion d'accès Housing"
+
+    exported_urlpatterns = [('housing', 'housing.urls')]

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,111 @@
+# -*- 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
+
+"""BIG FAT WARNING
+
+Ce code requiert une sévère factorisation avec vpn/models.py et vps/models.py
+
+"""
+
+
+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,124 @@
+# -*- 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')
+
+
+""" BIG FAT WARNING
+
+Ce code requiert une sévère factorisation avec vpn/tests.py et vps/tests.py
+
+"""
+
+
+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)
+

requirements.txt

@@ -8,6 +8,7 @@ django-activelink==0.4
 html2text
 django-polymorphic==0.7.2
 django-sendfile==0.3.10
+django-hijack>=2.1.10,<2.2
 django-localflavor==1.1
 django-netfields>=0.4,<0.5
 django-ldapdb==0.9.0

vpn/apps.py

@@ -1,14 +1,11 @@
 # -*- coding: utf-8 -*-
-from __future__ import unicode_literals
 
+from __future__ import unicode_literals
 from django.apps import AppConfig
 import coin.apps
 
-from . import urls
-
-
 class VPNConfig(AppConfig, coin.apps.AppURLs):
     name = 'vpn'
     verbose_name = "Tunnels VPN"
 
-    exported_urlpatterns = [('vpn', urls.urlpatterns)]
+    exported_urlpatterns = [('vpn', 'vpn.urls')]

vpn/models.py

@@ -15,6 +15,13 @@ from coin.configuration.models import Configuration
 from coin import utils
 from coin import validation
 
+"""BIG FAT WARNING
+
+Ce code requiert une sévère factorisation avec housing/models.py et
+vps/models.py
+
+"""
+
 
 class VPNConfiguration(CoinLdapSyncMixin, Configuration):
     url_namespace = "vpn"

vpn/tests.py

@@ -17,6 +17,14 @@ USING_POSTGRES = (settings.DATABASES['default']['ENGINE']
                   ==
                   'django.db.backends.postgresql_psycopg2')
 
+
+""" BIG FAT WARNING
+
+Ce code requiert une sévère factorisation avec housing/tests.py et vps/tests.py
+
+"""
+
+
 class VPNTestCase(TestCase):
     fixtures = ['example_pools.json', 'offers.json']
 
@@ -62,10 +70,11 @@ class VPNTestCase(TestCase):
             vpn.delete()
         Member.objects.get().delete()
 
-    @skipUnless(USING_POSTGRES, "Using a postgresql-only field")
-    def test_has_ipv4_endpoint(self):
-        vpn = VPNConfiguration.objects.all()[0]
-        self.assertIsNotNone(vpn.ipv4_endpoint)
+# ljf 2018-08-18 : I comment this tests which works only with the ip pool
+#    @skipUnless(USING_POSTGRES, "Using a postgresql-only field")
+#    def test_has_ipv4_endpoint(self):
+#        vpn = VPNConfiguration.objects.all()[0]
+#        self.assertIsNotNone(vpn.ipv4_endpoint)
 
     @skipUnless(USING_POSTGRES, "Using a postgresql-only field")
     def test_has_correct_ipv4_endpoint(self):
@@ -75,10 +84,11 @@ class VPNTestCase(TestCase):
             subnet = vpn.ip_subnet.get(ip_pool=self.v4_pool)
             self.assertIn(vpn.ipv4_endpoint, subnet.inet)
 
-    @skipUnless(USING_POSTGRES, "Using a postgresql-only field")
-    def test_has_ipv6_endpoint(self):
-        vpn = VPNConfiguration.objects.all()[0]
-        self.assertIsNotNone(vpn.ipv6_endpoint)
+# ljf 2018-08-18 : I comment this tests which works only with the ip pool
+#    @skipUnless(USING_POSTGRES, "Using a postgresql-only field")
+#    def test_has_ipv6_endpoint(self):
+#        vpn = VPNConfiguration.objects.all()[0]
+#        self.assertIsNotNone(vpn.ipv6_endpoint)
 
     @skipUnless(USING_POSTGRES, "Using a postgresql-only field")
     def test_has_correct_ipv6_endpoint(self):

vps/__init__.py

@@ -0,0 +1 @@
+default_app_config = 'vps.apps.VPSConfig'

vps/admin.py

@@ -0,0 +1,94 @@
+# -*- 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 VPSConfiguration, FingerPrint, Console
+
+
+class ConsoleInline(admin.TabularInline):
+    model = Console
+    extra = 0
+
+
+class FingerPrintInline(admin.TabularInline):
+    model = FingerPrint
+    extra = 0
+
+
+class VPSConfigurationInline(admin.StackedInline):
+    model = VPSConfiguration
+    # fk_name = 'offersubscription'
+    readonly_fields = ['configuration_ptr']
+
+
+class VPSConfigurationAdmin(ConfigurationAdminFormMixin, PolymorphicChildModelAdmin):
+    base_model = VPSConfiguration
+    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 = VPSConfigurationInline
+
+    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 vps in queryset:
+            if vps.activated != value:
+                vps.activated = value
+                vps.full_clean()
+                vps.save()
+                count += 1
+        action = "activated" if value else "deactivated"
+        msg = "{} VPS 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 VPSs"
+
+    def deactivate(self, request, queryset):
+        self.set_activation(request, queryset, False)
+    deactivate.short_description = "Deactivate selected VPSs"
+
+    def generate_endpoints_generic(self, request, queryset, v4=True, v6=True):
+        count = 0
+        for vps in queryset:
+            if vps.generate_endpoints(v4, v6):
+                vps.full_clean()
+                vps.save()
+                count += 1
+        msg = "{} VPS 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"
+
+VPSConfigurationAdmin.inlines = VPSConfigurationAdmin.inlines + (FingerPrintInline, ConsoleInline )
+admin.site.register(VPSConfiguration, VPSConfigurationAdmin)

vps/apps.py

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

vps/migrations/0001_initial.py

@@ -0,0 +1,62 @@
+# -*- 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 = [
+        ('contenttypes', '0002_remove_content_type_name'),
+        ('configuration', '0004_auto_20161015_1837'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Console',
+            fields=[
+                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
+                ('protocol', models.CharField(max_length=256, verbose_name='protocole', choices=[('VNC', 'VNC')])),
+                ('domain', models.CharField(max_length=256, null=True, verbose_name='nom de domaine', blank=True)),
+                ('port', models.IntegerField(null=True, verbose_name='port')),
+                ('password_link', models.URLField(help_text='Lien \xe0 usage unique (d\xe9truit apr\xe8s ouverture)', null=True, verbose_name='Mot de passe', blank=True)),
+            ],
+            options={
+                'verbose_name': 'Console',
+            },
+        ),
+        migrations.CreateModel(
+            name='FingerPrint',
+            fields=[
+                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
+                ('algo', models.CharField(max_length=256, verbose_name='algo', choices=[('ED25519', 'ED25519'), ('RSA', 'RSA'), ('ECDSA', 'ECDSA')])),
+                ('fingerprint', models.CharField(max_length=256, verbose_name='empreinte')),
+                ('length', models.IntegerField(null=True, verbose_name='longueur de la cl\xe9')),
+                ('polymorphic_ctype', models.ForeignKey(related_name='polymorphic_vps.fingerprint_set+', editable=False, to='contenttypes.ContentType', null=True)),
+            ],
+            options={
+                'verbose_name': 'Empreinte',
+            },
+        ),
+        migrations.CreateModel(
+            name='VPSConfiguration',
+            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 VPS', 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 VPS', null=True, verbose_name='IPv6')),
+                ('console', models.ForeignKey(verbose_name='console', blank=True, to='vps.Console', null=True)),
+            ],
+            options={
+                'verbose_name': 'VPS',
+            },
+            bases=('configuration.configuration',),
+        ),
+        migrations.AddField(
+            model_name='fingerprint',
+            name='vps',
+            field=models.ForeignKey(verbose_name='vps', to='vps.VPSConfiguration'),
+        ),
+    ]

vps/migrations/0002_auto_20170803_0350.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('vps', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='vpsconfiguration',
+            name='console',
+            field=models.OneToOneField(null=True, blank=True, to='vps.Console', verbose_name='console'),
+        ),
+    ]

vps/migrations/0003_auto_20170803_0411.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('vps', '0002_auto_20170803_0350'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='vpsconfiguration',
+            name='console',
+        ),
+        migrations.AddField(
+            model_name='console',
+            name='vps',
+            field=models.OneToOneField(default=1, verbose_name='vps', to='vps.VPSConfiguration'),
+            preserve_default=False,
+        ),
+    ]

vps/models.py

@@ -0,0 +1,145 @@
+# -*- 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
+
+
+"""BIG FAT WARNING
+
+Ce code requiert une sévère factorisation avec vpn/models.py et
+housing/models.py
+
+"""
+
+FINGERPRINT_TYPES = (
+    ('ED25519', 'ED25519'),
+    ('RSA', 'RSA'),
+    ('ECDSA', 'ECDSA')
+)
+
+PROTOCOLE_TYPES = (
+    ('VNC', 'VNC'),
+)
+
+
+class VPSConfiguration(Configuration):
+    url_namespace = "vps"
+    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 VPS")
+    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 VPS")
+    objects = NetManager()
+
+    def get_absolute_url(self):
+        return reverse('vps: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 'VPS ' + str(self.offersubscription.member.username) + ' ' + self.offersubscription.member.last_name
+
+    class Meta:
+        verbose_name = 'VPS'
+
+class FingerPrint(PolymorphicModel):
+    vps = models.ForeignKey(VPSConfiguration, verbose_name="vps")
+    algo = models.CharField(max_length=256, verbose_name="algo",
+                            choices=FINGERPRINT_TYPES)
+    fingerprint = models.CharField(max_length=256, verbose_name="empreinte")
+    length = models.IntegerField(verbose_name="longueur de la clé", null=True)
+
+    class Meta:
+        verbose_name = 'Empreinte'
+
+
+class Console(models.Model):
+    vps = models.OneToOneField(VPSConfiguration, verbose_name="vps")
+    protocol = models.CharField(max_length=256, verbose_name="protocole",
+                            choices=PROTOCOLE_TYPES)
+    domain = models.CharField(max_length=256, verbose_name="nom de domaine",
+                                blank=True, null=True)
+    port = models.IntegerField(verbose_name="port", null=True)
+    password_link = models.URLField(verbose_name="Mot de passe", blank=True,
+                           null=True, help_text="Lien à usage unique (détruit après ouverture)")
+    class Meta:
+        verbose_name = 'Console'
+

vps/templates/vps/fragments/password.html

@@ -0,0 +1,8 @@
+<tr id="password">
+    <td class="center"><span class="label">Mot de passe</span></td>
+    <td><span class="pass">{{ password }}</span></td>
+</tr>
+<tr>
+    <td class="warning" colspan="2">Ce mot de passe ne sera affiché qu'une seule fois. Si vous le perdez, il faudra en générer un nouveau.</td>
+</tr>
+

vps/templates/vps/vps.html

@@ -0,0 +1,109 @@
+{% extends "base.html" %}
+
+{% load subnets %}
+
+{% block content %}
+<div class="row">
+    <h2>Configuration du VPS</h2>
+    {% if form %}
+        <form class="flatform" action="{{ object.get_absolute_url }}" method="post">{% csrf_token %}
+        <p class="legend">Quand vous aurez terminé vos modifications, cliquez sur <input class="button" type="submit" value="Valider" /></p>
+    {% endif %}
+    {% for message in messages %}
+        <div class="message eat-up{% if message.tags %} {{ message.tags }}{% endif %}">
+            {{ message }}
+        </div>
+    {% endfor %}
+
+    {% if form %}
+        {% if form.non_field_errors or form.ipv4_endpoint.errors or form.ipv6_endpoint.errors %}
+            <div class="alert-box alert nogap">
+            {{ form.non_field_errors }}
+            {{ form.ipv4_endpoint.errors }}
+            {{ form.ipv6_endpoint.errors }}
+            </div>
+        {% endif %}
+    {% endif %}
+    <div class="large-12 columns">
+        <div class="panel">
+            <h3>Authentification</h3>
+            <table class="full-width">
+                {% if object.fingerprint_set.all %}
+                <tr>
+                    <td class="center"><span class="label">Empreinte(s)</span></td>
+                    <td>{% for fingerprint in object.fingerprint_set.all %}
+                        {{ fingerprint.length }} {{ fingerprint.fingerprint }} ({{ fingerprint.algo }}){% if not forloop.last %}<br />{% endif %}
+                        {% endfor %}</td>
+                </tr>
+                {% endif %}
+                {% if object.console %}
+                <tr>
+                    <td class="center"><span class="label">Console {{object.console.protocol }}</span></td>
+                    <td>
+                        {{ object.console.domain }}:{{ object.console.port }}<br />
+
+                    <a href="{{object.console.password_link}}">Voir le mot de passe (lien supprimé après ouverture)</a>
+                    </td>
+                </tr>
+                {% endif %}
+                <tr class="flatfield">
+                    {% if form %}
+                        <td class="center">{{ form.comment.label_tag }}</td>
+                        <td>{{ form.comment }}</td>
+                    {% else %}
+                    <td class="center"><span class="label">Commentaire</span></td>
+                        <td>{{ object.comment }}</td>
+                        
+                    {% endif %}
+                </tr>
+                <tr>
+                    <td class="center boolviewer" colspan="2">
+                    {% if form %}
+                        <input type="checkbox" disabled="disabled"{% if object.activated %} checked="checked"{% endif %} />
+                    {% endif %}
+                        <span>Ce VPS est {{ object.activated|yesno:"activé,désactivé" }}</span>
+                    </td>
+                </tr>
+            </table>
+        </div>
+    </div>
+
+    <div class="large-12 columns">
+        <div class="panel">
+            <h3>Adresses IP</h3>
+            <table class="full-width">
+                {% if form %}
+                    <tr class="flatfield">
+                        <td class="center">{{ form.ipv4_endpoint.label_tag }}</td>
+                        <td{% if form.non_field_errors or form.ipv4_endpoint.errors %} class="errored"{% endif %}>{{ form.ipv4_endpoint }}</td>
+                    </tr>
+                    <tr class="flatfield">
+                        <td class="center">{{ form.ipv6_endpoint.label_tag }}</td>
+                        <td{% if form.non_field_errors or form.ipv6_endpoint.errors %} class="errored"{% endif %}>{{ form.ipv6_endpoint }}</td>
+                    </tr>
+                {% else %}
+                    <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>
+                {% endif %}
+                <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>
+    {% if form %}
+    <p class="formcontrol"><input class="button" type="submit" value="Valider" /></p>
+    </form>
+    {% endif %}
+</div>
+
+{% endblock %}

vps/tests.py

@@ -0,0 +1,122 @@
+# -*- 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 VPSConfiguration
+
+
+""" BIG FAT WARNING
+
+Ce code requiert une sévère factorisation avec vpn/tests.py et housing/tests.py
+
+"""
+
+
+USING_POSTGRES = (settings.DATABASES['default']['ENGINE']
+                  ==
+                  'django.db.backends.postgresql_psycopg2')
+
+class VPSTestCase(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="VPSConfiguration")[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 VPS 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()
+        vps = VPSConfiguration(offersubscription=abo)
+        vps.full_clean()
+        vps.save()
+        v6 = IPSubnet(ip_pool=self.v6_pool, configuration=vps)
+        v6.full_clean()
+        v6.save()
+        v4 = IPSubnet(ip_pool=self.v4_pool, configuration=vps)
+        v4.full_clean()
+        v4.save()
+
+        # Create additional VPS, 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()
+            vps = VPSConfiguration(offersubscription=abo)
+            vps.full_clean()
+            vps.save()
+
+    def tearDown(self):
+        """Properly clean up objects, so that they don't stay in LDAP"""
+        for vps in VPSConfiguration.objects.all():
+            vps.delete()
+        Member.objects.get().delete()
+
+# ljf 2018-08-18 : I comment this tests which works only with the ip pool
+#    @skipUnless(USING_POSTGRES, "Using a postgresql-only field")
+#    def test_has_ipv4_endpoint(self):
+#        vps = VPSConfiguration.objects.all()[0]
+#        self.assertIsNotNone(vps.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."""
+        vps = VPSConfiguration.objects.all()[0]
+        if vps.ipv4_endpoint is not None:
+            subnet = vps.ip_subnet.get(ip_pool=self.v4_pool)
+            self.assertIn(vps.ipv4_endpoint, subnet.inet)
+
+# ljf 2018-08-18 : I comment this tests which works only with the ip pool
+# improvement in arnprod branch
+#    @skipUnless(USING_POSTGRES, "Using a postgresql-only field")
+#    def test_has_ipv6_endpoint(self):
+#        vps = VPSConfiguration.objects.all()[0]
+#        self.assertIsNotNone(vps.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."""
+        vps = VPSConfiguration.objects.all()[0]
+        if vps.ipv6_endpoint is not None:
+            subnet = vps.ip_subnet.get(ip_pool=self.v6_pool)
+            self.assertIn(vps.ipv6_endpoint, subnet.inet)
+
+    @skipUnless(USING_POSTGRES, "Using a postgresql-only field")
+    def test_change_v4subnet_is_vps_endpoint_correct(self):
+        vps = VPSConfiguration.objects.all()[0]
+        subnet = vps.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_vps_endpoint_correct(self):
+        vps = VPSConfiguration.objects.all()[0]
+        subnet = vps.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_has_multiple_vps(self):
+        vpss = VPSConfiguration.objects.all()
+        self.assertEqual(len(vpss), 6)

vps/urls.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.conf.urls import patterns, url
+
+from .views import VPSView
+
+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+)$', VPSView.as_view(template_name="vps/vps.html"), name="details"),
+)

vps/views.py

@@ -0,0 +1,36 @@
+# -*- 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 VPSConfiguration
+
+
+class VPSView(SuccessMessageMixin, UpdateView):
+    model = VPSConfiguration
+    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(VPSView, self).dispatch(*args, **kwargs)
+
+    def get_form(self, form_class=None):
+        if settings.MEMBER_CAN_EDIT_VPS_CONF:
+            return super(VPSView, self).get_form(form_class)
+        return None
+
+    def get_object(self):
+        if self.request.user.is_superuser:
+            return get_object_or_404(VPSConfiguration, pk=self.kwargs.get("pk"))
+        # For normal users, ensure the VPS belongs to them.
+        return get_object_or_404(VPSConfiguration, pk=self.kwargs.get("pk"),
+                                 offersubscription__member=self.request.user)
+