Merged from log:branch/yaco/liaison@2570: Yaco's port and rewrite of the Liaison Statement Management Tool.

 - Legacy-Id: 2572

Author: levkowetz

changelog

@@ -1,3 +1,70 @@
+ietfdb (3.07)
+
+  From esanchez@yaco.es:
+
+  * Merged in Yaco's Liaison Management Tool Port & Rewrite.  Enjoy!
+
+  Note: Deploying this release requires additional steps; to verify
+  that liaison related settings in settings.py are correct, and to create
+  new tables and update existing tables and table content.  The latter
+  is done as South migrations (see http://south.aeracode.org/ for more
+  info on the South app).  More extensiive documentation about the actions
+  needed are provided in the user manual (doc/LSMT_user_manual.pdf in
+  the release).  The brief version follows:
+
+    # 8<----------
+    # First the regular checkout and prepare:
+
+       cd /a/www/ietf-datatracker
+       svn co http://svn.tools.ietf.org/svn/tools/ietfdb/tags/3.07
+       cp web/ietf/settings_local.py 3.07/ietf/
+       cd 3.07
+
+    # Verify that the new variables in settings.py are correct; if not,
+    # add the correct settings in settings_local.py and inform the release
+    # manager of the correct settings so they can be incorporated in the
+    # next release.  The variables in question are (as set in the release):
+    #
+    # # The email address from wich all liaison emails come:
+    # LIAISON_UNIVERSAL_FROM = 'Liaison Statement Management Tool <lsmt@' + IETF_DOMAIN + '>'
+    #
+    # # The filesystem path where the liaison attachments will be saved:
+    # LIAISON_ATTACH_PATH = '/a/www/ietf-datatracker/documents/LIAISON/'
+    #
+    # # The url from where the webserver serves the liaison attachments
+    # LIAISON_ATTACH_URL = '/documents/LIAISON/'
+
+    # Next, the changes to the MySQL tables will be done.
+    # You can list the table migrations which will be applied if desired,
+    # this should list migrations from 0001_... to 0009_... under liaisons:
+
+       PYTHONPATH=$PWD ietf/manage.py migrate --list
+
+    # Apply the migrations:
+ 
+       PYTHONPATH=$PWD ietf/manage.py migrate
+
+    # Then carry on with the usual actions:
+
+       cd ../
+       rm ./web; ln -s 3.07 web
+       sudo /etc/init.d/apache restart
+
+    # 8<----------
+
+  Once the datatracker is up and running with the new liaison tool in
+  place, liaison role assignments have to be done as described in
+  the LSMT user manual (in doc/LSMT_user_manual.pdf) page 14, summarized
+  by Patrik on the yaco-liaison-tool mailing list:
+
+    1. Add the IAB and IETF chairs, wg chairs, area directors etc as
+    apropriate (as described in the document).
+
+    2. Add the liaisons in the IETF assigned and named on the IAB list of
+    liaisons.
+
+ -- Henrik Levkowetz <henrik@levkowetz.com>  22 Oct 2010 13:59:04 +0200
+
 ietfdb (3.06)
 
   From rjsparks@nostrum.com:

doc/LSMT_user_manual.pdf

@@ -39,6 +39,9 @@
 
 from ietf.utils import log
 
+AUTOMATIC_GROUPS = ["Area_Director", "Secretariat", "IETF_Chair",
+                    "IAB_Chair", "IRTF_Chair", ]
+
 class IetfUserBackend(RemoteUserBackend):
 
     def find_groups(username):
@@ -56,6 +59,8 @@ def find_groups(username):
         Session_Chair          chairing a non-WG session in IETF meeting
         Ex_Area_Director       past AD
         """
+        # Any group name added by this method should be added to the 
+        # AUTOMATIC_GROUPS list
         groups = []
         try:
             login = IESGLogin.objects.get(login_name=username)
@@ -94,9 +99,12 @@ def authenticate(self, remote_user):
             profile = IetfUserProfile(user=user)
             profile.save()
 
+        # Remove any automatic groups, the proper ones will be retrieved by 
+        # find_groups
+        groups = [group for group in user.groups.exclude(name__in=AUTOMATIC_GROUPS)]
+
         # Update group memberships
         group_names = IetfUserBackend.find_groups(user.username)
-        groups = []
         for group_name in group_names:
             # Create groups as needed
             group,created = Group.objects.get_or_create(name=group_name)
@@ -105,4 +113,3 @@ def authenticate(self, remote_user):
             groups.append(group)
         user.groups = groups
         return user
-

ietf/ietfauth/auth.py

@@ -0,0 +1,98 @@
+from ietf.idtracker.models import Role, PersonOrOrgInfo
+
+
+LIAISON_EDIT_GROUPS = ['Liaison_Manager', 'Secretariat']
+
+def get_ietf_chair():
+    person = PersonOrOrgInfo.objects.filter(role=Role.IETF_CHAIR)
+    return person and person[0] or None
+
+
+def get_iesg_chair():
+    return get_ietf_chair()
+
+
+def get_iab_chair():
+    person = PersonOrOrgInfo.objects.filter(role=Role.IAB_CHAIR)
+    return person and person[0] or None
+
+
+def get_iab_executive_director():
+    person = PersonOrOrgInfo.objects.filter(role=Role.IAB_EXCUTIVE_DIRECTOR)
+    return person and person[0] or None
+
+
+def get_person_for_user(user):
+    try:
+        return user.get_profile().person()
+    except:
+        return None
+
+
+def is_areadirector(person):
+    return bool(person.areadirector_set.all())
+
+
+def is_wgchair(person):
+    return bool(person.wgchair_set.all())
+
+
+def is_wgsecretary(person):
+    return bool(person.wgsecretary_set.all())
+
+
+def has_role(person, role):
+    return bool(person.role_set.filter(pk=role))
+
+
+def is_ietfchair(person):
+    return has_role(person, Role.IETF_CHAIR)
+
+
+def is_iabchair(person):
+    return has_role(person, Role.IAB_CHAIR)
+
+
+def is_iab_executive_director(person):
+    return has_role(person, Role.IAB_EXCUTIVE_DIRECTOR)
+
+
+def can_add_outgoing_liaison(user):
+    person = get_person_for_user(user)
+    if not person:
+        return False
+
+    if (is_areadirector(person) or is_wgchair(person) or
+        is_wgsecretary(person) or is_ietfchair(person) or
+        is_iabchair(person) or is_iab_executive_director(person) or
+        is_ietf_liaison_manager(user)):
+        return True
+    return False
+
+
+def is_sdo_liaison_manager(person):
+    return bool(person.liaisonmanagers_set.all())
+
+
+def is_sdo_authorized_individual(person):
+    return bool(person.sdoauthorizedindividual_set.all())
+
+
+def is_ietf_liaison_manager(user):
+    return bool(user.groups.filter(name='Liaison_Manager'))
+
+
+def can_add_incoming_liaison(user):
+    person = get_person_for_user(user)
+    if not person:
+        return False
+
+    if (is_sdo_liaison_manager(person) or
+        is_sdo_authorized_individual(person) or
+        is_ietf_liaison_manager(user)):
+        return True
+    return False
+
+
+def can_add_liaison(user):
+    return can_add_incoming_liaison(user) or can_add_outgoing_liaison(user)

ietf/liaisons/accounts.py

@@ -1,16 +1,123 @@
 #coding: utf-8
+from django import template
 from django.contrib import admin
-from ietf.liaisons.models import *
-                
+from django.contrib.admin.util import unquote
+from django.core.exceptions import PermissionDenied
+from django.core.management import load_command_class
+from django.http import Http404
+from django.shortcuts import render_to_response
+from django.utils.encoding import force_unicode
+from django.utils.functional import update_wrapper
+from django.utils.html import escape
+from django.utils.translation import ugettext as _
+
+from ietf.liaisons.models import (FromBodies, LiaisonDetail, LiaisonPurpose,
+                                  SDOs, LiaisonManagers, SDOAuthorizedIndividual)
+
+
 class FromBodiesAdmin(admin.ModelAdmin):
     pass
-admin.site.register(FromBodies, FromBodiesAdmin)
+
 
 class LiaisonDetailAdmin(admin.ModelAdmin):
-    pass
-admin.site.register(LiaisonDetail, LiaisonDetailAdmin)
+    ordering = ('title', )
+    fields = ('title', 'body','submitted_date', 'last_modified_date', 'to_email', 'cc1', 'cc2', 'to_poc',
+              'response_contact', 'technical_contact', 'purpose', 'purpose_text', 'deadline_date', 'taken_care',
+              'related_to')
+    raw_id_fields=['related_to']
 
 class LiaisonPurposeAdmin(admin.ModelAdmin):
-    pass
-admin.site.register(LiaisonPurpose, LiaisonPurposeAdmin)
+    ordering = ('purpose_text', )
+
+
+class LiaisonManagersInline(admin.TabularInline):
+    model = LiaisonManagers
+    raw_id_fields=['person']
+
+
+class SDOAuthorizedIndividualInline(admin.TabularInline):
+    model = SDOAuthorizedIndividual
+    raw_id_fields=['person']
+
+
+class LiaisonManagersAdmin(admin.ModelAdmin):
+    ordering = ('person__first_name', 'person__last_name' )
+    fields = ('person', 'sdo')
+    raw_id_fields=['person']
+
+
+class SDOAuthorizedIndividualAdmin(admin.ModelAdmin):
+    raw_id_fields=['person']
+
 
+class SDOsAdmin(admin.ModelAdmin):
+    inlines = [LiaisonManagersInline, SDOAuthorizedIndividualInline]
+
+    def get_urls(self):
+        from django.conf.urls.defaults import patterns, url
+
+        def wrap(view):
+            def wrapper(*args, **kwargs):
+                return self.admin_site.admin_view(view)(*args, **kwargs)
+            return update_wrapper(wrapper, view)
+
+        info = self.model._meta.app_label, self.model._meta.module_name
+
+        urls = patterns('',
+            url(r'^reminder/$',
+                wrap(self.send_reminder),
+                name='%s_%s_reminder' % info),
+            url(r'^(.+)/reminder/$',
+                wrap(self.send_one_reminder),
+                name='%s_%s_one_reminder' % info),
+            )
+        urls += super(SDOsAdmin, self).get_urls()
+        return urls
+
+    def send_reminder(self, request, sdo=None):
+        opts = self.model._meta
+        app_label = opts.app_label
+
+        output = None
+        sdo_pk = sdo and sdo.pk or None
+        if request.method == 'POST' and request.POST.get('send', False):
+            command = load_command_class('ietf.liaisons', 'remind_update_sdo_list')
+            output=command.handle(return_output=True, sdo_pk=sdo_pk)
+            output='\n'.join(output)
+
+        context = {
+            'opts': opts,
+            'has_change_permission': self.has_change_permission(request),
+            'app_label': app_label,
+            'output': output,
+            'sdo': sdo,
+            }
+        return render_to_response('admin/liaisons/sdos/send_reminder.html',
+                                  context,
+                                  context_instance = template.RequestContext(request, current_app=self.admin_site.name),
+                                 )
+
+    def send_one_reminder(self, request, object_id):
+        model = self.model
+        opts = model._meta
+
+        try:
+            obj = self.queryset(request).get(pk=unquote(object_id))
+        except model.DoesNotExist:
+            obj = None
+
+        if not self.has_change_permission(request, obj):
+            raise PermissionDenied
+
+        if obj is None:
+            raise Http404(_('%(name)s object with primary key %(key)r does not exist.') % {'name': force_unicode(opts.verbose_name), 'key': escape(object_id)})
+
+        return self.send_reminder(request, sdo=obj)
+
+
+#admin.site.register(FromBodies, FromBodiesAdmin)
+admin.site.register(LiaisonDetail, LiaisonDetailAdmin)
+admin.site.register(LiaisonPurpose, LiaisonPurposeAdmin)
+admin.site.register(SDOs, SDOsAdmin)
+admin.site.register(LiaisonManagers, LiaisonManagersAdmin)
+admin.site.register(SDOAuthorizedIndividual, SDOAuthorizedIndividualAdmin)

ietf/liaisons/admin.py

@@ -0,0 +1,14 @@
+from ietf.ietfauth.decorators import _CheckLogin403
+from ietf.liaisons.accounts import can_add_liaison
+
+
+def can_submit_liaison(view_func=None):
+
+    def decorate(view_func):
+        return _CheckLogin403(
+            view_func,
+            lambda u: can_add_liaison(u),
+            "Restricted to participants who are authorized to submit liaison statements on behalf of the various IETF entities")
+    if view_func:
+        return decorate(view_func)
+    return decorate