Add models for new meeting schema and an importer, clean up person

import slightly
 - Legacy-Id: 3282

Author: OleLaursen

ietf/meeting/models.py

@@ -1,3 +1,139 @@
-# Copyright The IETF Trust 2007, All Rights Reserved
+# old meeting models can be found in ../proceedings/models.py
+
+import pytz
+
+from django.db import models
+from timedeltafield import TimedeltaField
+
+from redesign.group.models import Group
+from redesign.person.models import Person
+from redesign.name.models import TimeSlotTypeName, SessionStatusName, ConstraintName
+
+countries = pytz.country_names.items()
+countries.sort(lambda x,y: cmp(x[1], y[1]))
+
+timezones = [(name, name) for name in pytz.common_timezones]
+timezones.sort()
+
+class Meeting(models.Model):
+    # Number is not an integer any more, in order to be able to accomodate
+    # interim meetings (and other variations?)
+    number = models.CharField(max_length=64)
+    # Date is useful when generating a set of timeslot for this meeting, but
+    # is not used to determine date for timeslot instances thereafter, as
+    # they have their own datetime field.
+    date = models.DateField()           
+    city = models.CharField(blank=True, max_length=255)
+    country = models.CharField(blank=True, max_length=2, choices=countries)
+    # We can't derive time-zone from country, as there are some that have
+    # more than one timezone, and the pytz module doesn't provide timezone
+    # lookup information for all relevant city/country combinations.
+    time_zone = models.CharField(blank=True, max_length=255, choices=timezones)
+    venue_name = models.CharField(blank=True, max_length=255)
+    venue_addr = models.TextField(blank=True)
+    break_area = models.CharField(blank=True, max_length=255)
+    reg_area = models.CharField(blank=True, max_length=255)
+    
+    def __str__(self):
+	return "IETF-%s" % (self.number)
+    def get_meeting_date (self,offset):
+        return self.date + datetime.timedelta(days=offset)
+    # cut-off dates (draft submission cut-of, wg agenda cut-off, minutes
+    # submission cut-off), and more, are probably methods of this class,
+    # rather than fields on a Proceedings class.
+
+    @classmethod
+    def get_first_cut_off(cls):
+        date = cls.objects.all().order_by('-date')[0].date
+        offset = datetime.timedelta(days=settings.FIRST_CUTOFF_DAYS)
+        return date - offset
+
+    @classmethod
+    def get_second_cut_off(cls):
+        date = cls.objects.all().order_by('-date')[0].date
+        offset = datetime.timedelta(days=settings.SECOND_CUTOFF_DAYS)
+        return date - offset
+
+    @classmethod
+    def get_ietf_monday(cls):
+        date = cls.objects.all().order_by('-date')[0].date
+        return date + datetime.timedelta(days=-date.weekday(), weeks=1)
+
+
+class Room(models.Model):
+    meeting = models.ForeignKey(Meeting)
+    name = models.CharField(max_length=255)
+
+    def __unicode__(self):
+        return self.name
+
+class TimeSlot(models.Model):
+    """
+    Everything that would appear on the meeting agenda of a meeting is mapped
+    to a time slot, including breaks (i.e., also NonSession+NonSessionRef.
+    Sessions are connected to TimeSlots during scheduling.
+    A template function to populate a meeting with an appropriate set of TimeSlots
+    is probably also needed.
+    """
+    meeting = models.ForeignKey(Meeting)
+    type = models.ForeignKey(TimeSlotTypeName)
+    name = models.CharField(max_length=255)
+    time = models.DateTimeField()
+    duration = TimedeltaField()
+    location = models.ForeignKey(Room, blank=True, null=True)
+    show_location = models.BooleanField(default=True)
+
+    def __unicode__(self):
+        location = self.get_location()
+        if not location:
+            location = "(no location)"
+            
+        return u"%s: %s-%s %s, %s" % (self.meeting.number, self.time.strftime("%m-%d %H:%M"), (self.time + self.duration).strftime("%H:%M"), self.name, location)
+
+    def get_location(self):
+        location = self.location
+        if location:
+            location = location.name
+        elif self.type_id == "reg":
+            location = self.meeting.reg_area
+        elif self.type_id == "break":
+            location = self.meeting.break_area
+                
+        if not self.show_location:
+            location = ""
+            
+        return location
+        
+    
+class Constraint(models.Model):
+    """Specifies a constraint on the scheduling between source and
+    target, e.g. some kind of conflict."""
+    meeting = models.ForeignKey(Meeting)
+    source = models.ForeignKey(Group, related_name="constraint_source_set")
+    target = models.ForeignKey(Group, related_name="constraint_target_set")
+    name = models.ForeignKey(ConstraintName)
+
+    def __unicode__(self):
+        return u"%s %s %s" % (self.source, self.name.lower(), self.target)
+
+class Session(models.Model):
+    meeting = models.ForeignKey(Meeting)
+    timeslot = models.ForeignKey(TimeSlot, null=True, blank=True) # Null until session has been scheduled
+    group = models.ForeignKey(Group)    # The group type determines the session type.  BOFs also need to be added as a group.
+    attendees = models.IntegerField(null=True, blank=True)
+    agenda_note = models.CharField(blank=True, max_length=255)
+    #
+    requested = models.DateTimeField()
+    requested_by = models.ForeignKey(Person)
+    requested_duration = TimedeltaField()
+    comments = models.TextField()
+    #
+    status = models.ForeignKey(SessionStatusName)
+    scheduled = models.DateTimeField(null=True, blank=True)
+    modified = models.DateTimeField(null=True, blank=True)
+
+# Agendas, Minutes and Slides are all mapped to Document.
+
+# IESG history is extracted from GroupHistory, rather than hand coded in a
+# separate table.
 
-# Meeting models can be found under ../proceedings/

ietf/meeting/timedeltafield.py

@@ -0,0 +1,191 @@
+# -*- coding: iso-8859-1 -*-
+# $Id: TimedeltaField.py 1787 2011-04-20 07:09:57Z tguettler $
+# $HeadURL: svn+ssh://svnserver/svn/djangotools/trunk/dbfields/TimedeltaField.py $
+
+# from http://djangosnippets.org/snippets/1060/ with some fixes
+
+# Python
+import datetime
+
+# Django
+from django import forms
+from django.db import models
+from django.utils.safestring import mark_safe
+from django.utils.translation import ugettext_lazy as _
+
+#Djangotools
+#from djangotools.utils.southutils import add_introspection_rules_from_baseclass
+
+SECS_PER_DAY=3600*24
+
+class TimedeltaField(models.Field):
+    u'''
+    Store Python's datetime.timedelta in an integer column.
+    Most database systems only support 32 bit integers by default.
+    '''
+    __metaclass__ = models.SubfieldBase
+    empty_strings_allowed = False
+    
+    def __init__(self, *args, **kwargs):
+        super(TimedeltaField, self).__init__(*args, **kwargs)
+
+    def to_python(self, value):
+        if (value is None) or isinstance(value, datetime.timedelta):
+            return value
+
+        try:
+            # else try to convert to int (e.g. from string)
+            value = int(value)
+        except (TypeError, ValueError):
+            raise exceptions.ValidationError(
+                _("This value must be an integer or a datetime.timedelta."))
+
+        return datetime.timedelta(seconds=value)
+
+    def get_internal_type(self):
+        return 'IntegerField'
+
+    def get_db_prep_lookup(self, lookup_type, value, connection=None, prepared=False):
+        raise NotImplementedError()  # SQL WHERE
+
+    def get_db_prep_save(self, value, connection=None, prepared=False):
+        if (value is None) or isinstance(value, int):
+            return value
+        return SECS_PER_DAY*value.days+value.seconds
+
+    def formfield(self, *args, **kwargs):
+        defaults={'form_class': TimedeltaFormField}
+        defaults.update(kwargs)
+        return super(TimedeltaField, self).formfield(*args, **defaults)
+
+    def value_to_string(self, obj):
+        value = self._get_val_from_obj(obj)
+        return self.get_db_prep_value(value)
+
+#South Plugin registrieren
+#add_introspection_rules_from_baseclass(TimedeltaField, ["^djangotools\.dbfields\.TimedeltaField"])
+
+class TimedeltaFormField(forms.Field):
+    default_error_messages = {
+        'invalid':  _(u'Enter a whole number.'),
+        }
+
+    def __init__(self, *args, **kwargs):
+        defaults={'widget': TimedeltaWidget}
+        defaults.update(kwargs)
+        super(TimedeltaFormField, self).__init__(*args, **defaults)
+
+    def clean(self, value):
+        # value comes from Timedelta.Widget.value_from_datadict(): tuple of strings
+        super(TimedeltaFormField, self).clean(value)
+        assert len(value)==len(self.widget.inputs), (value, self.widget.inputs)
+        i=0
+        for value, multiply in zip(value, self.widget.multiply):
+            try:
+                i+=int(value)*multiply
+            except ValueError, TypeError:
+                raise forms.ValidationError(self.error_messages['invalid'])
+        return i
+
+class TimedeltaWidget(forms.Widget):
+    INPUTS=['days', 'hours', 'minutes', 'seconds']
+    MULTIPLY=[60*60*24, 60*60, 60, 1]
+    def __init__(self, attrs=None):
+        self.widgets=[]
+        if not attrs:
+            attrs={}
+        inputs=attrs.get('inputs', self.INPUTS)
+        multiply=[]
+        for input in inputs:
+            assert input in self.INPUTS, (input, self.INPUT)
+            self.widgets.append(forms.TextInput(attrs=attrs))
+            multiply.append(self.MULTIPLY[self.INPUTS.index(input)])
+        self.inputs=inputs
+        self.multiply=multiply
+        super(TimedeltaWidget, self).__init__(attrs)
+
+    def render(self, name, value, attrs):
+        if value is None:
+            values=[0 for i in self.inputs]
+        elif isinstance(value, datetime.timedelta):
+            values=split_seconds(value.days*SECS_PER_DAY+value.seconds, self.inputs, self.multiply)
+        elif isinstance(value, int):
+            # initial data from model
+            values=split_seconds(value, self.inputs, self.multiply)
+        else:
+            assert isinstance(value, tuple), (value, type(value))
+            assert len(value)==len(self.inputs), (value, self.inputs)
+            values=value
+        id=attrs.pop('id')
+        assert not attrs, attrs
+        rendered=[]
+        for input, widget, val in zip(self.inputs, self.widgets, values):
+            rendered.append(u'%s %s' % (_(input), widget.render('%s_%s' % (name, input), val)))
+        return mark_safe('<div id="%s">%s</div>' % (id, ' '.join(rendered)))
+
+    def value_from_datadict(self, data, files, name):
+        # Don't throw ValidationError here, just return a tuple of strings.
+        ret=[]
+        for input, multi in zip(self.inputs, self.multiply):
+            ret.append(data.get('%s_%s' % (name, input), 0))
+        return tuple(ret)
+
+    def _has_changed(self, initial_value, data_value):
+        # data_value comes from value_from_datadict(): A tuple of strings.
+        if initial_value is None:
+            return bool(set(data_value)!=set([u'0']))
+        assert isinstance(initial_value, datetime.timedelta), initial_value
+        initial=tuple([unicode(i) for i in split_seconds(initial_value.days*SECS_PER_DAY+initial_value.seconds, self.inputs, self.multiply)])
+        assert len(initial)==len(data_value), (initial, data_value)
+        return bool(initial!=data_value)
+
+def main():
+    assert split_seconds(1000000)==[11, 13, 46, 40]
+
+    field=TimedeltaField()
+
+    td=datetime.timedelta(days=10, seconds=11)
+    s=field.get_db_prep_save(td)
+    assert isinstance(s, int), (s, type(s))
+    td_again=field.to_python(s)
+    assert td==td_again, (td, td_again)
+
+    td=datetime.timedelta(seconds=11)
+    s=field.get_db_prep_save(td)
+    td_again=field.to_python(s)
+    assert td==td_again, (td, td_again)
+
+    field=TimedeltaFormField()
+    assert field.widget._has_changed(datetime.timedelta(seconds=0), (u'0', u'0', u'0', u'0',)) is False
+    assert field.widget._has_changed(None, (u'0', u'0', u'0', u'0',)) is False
+    assert field.widget._has_changed(None, (u'0', u'0')) is False
+    assert field.widget._has_changed(datetime.timedelta(days=1, hours=2, minutes=3, seconds=4), (u'1', u'2', u'3', u'4',)) is False
+
+    for secs, soll, kwargs in [
+        (100, [0, 0, 1, 40], dict()),
+        (100, ['0days', '0hours', '1minutes', '40seconds'], dict(with_unit=True)),
+        (100, ['1minutes', '40seconds'], dict(with_unit=True, remove_leading_zeros=True)),
+        (100000, ['1days', '3hours'], dict(inputs=['days', 'hours'], with_unit=True, remove_leading_zeros=True)),
+        ]:
+        ist=split_seconds(secs, **kwargs)
+        if ist!=soll:
+            raise Exception('geg=%s soll=%s ist=%s kwargs=%s' % (secs, soll, ist, kwargs))
+
+    print "unittest OK"
+
+def split_seconds(secs, inputs=TimedeltaWidget.INPUTS, multiply=TimedeltaWidget.MULTIPLY,
+                  with_unit=False, remove_leading_zeros=False):
+    ret=[]
+    assert len(inputs)<=len(multiply), (inputs, multiply)
+    for input, multi in zip(inputs, multiply):
+        count, secs = divmod(secs, multi)
+        if remove_leading_zeros and not ret and not count:
+            continue
+        if with_unit:
+            ret.append('%s%s' % (count, input))
+        else:
+            ret.append(count)
+    return ret
+
+if __name__=='__main__':
+    main()