initial incomplete version

rowers/models.py

@@ -1664,6 +1664,7 @@ class PlannedSession(models.Model):
         ('cycletarget','Total for a time period'),
         ('coursetest','OTW test over a course'),
         ('race','Virtual Race'),
+        ('indoorrace','Indoor Virtual Race'),
         )
 
     sessionmodechoices = (
@@ -1772,7 +1773,7 @@ class PlannedSession(models.Model):
         else:
             self.sessionunit = 'None'
 
-        if self.sessiontype == 'test':
+        if self.sessiontype == 'test' or self.sessiontype == 'indoorrace':
             if self.sessionmode not in ['distance','time']:
                 if self.sessionvalue < 100:
                     self.sessionmode = 'time'
@@ -1937,7 +1938,126 @@ def get_course_timezone(course):
 
     return timezone_str
 
+class IndoorVirtualRaceForm(ModelForm):
+    registration_closure = forms.SplitDateTimeField(widget=AdminSplitDateTime(),required=False)
+    evaluation_closure = forms.SplitDateTimeField(widget=AdminSplitDateTime(),required=True)
+    timezone = forms.ChoiceField(initial='UTC',
+                                 choices=[(x,x) for x in pytz.common_timezones],
+                                 label='Time Zone')
+    
+    class Meta:
+        model = VirtualRace
+        fields = [
+            'name',
+            'startdate',
+            'start_time',
+            'enddate',
+            'end_time',
+            'timezone',
+            'sessionvalue',
+            'sessionunit',
+            'registration_form',
+            'registration_closure',
+            'evaluation_closure',
+            'comment',
+            'contact_phone',
+            'contact_email',
+            ]
+
+        dateTimeOptions = {
+            'format': 'yyyy-mm-dd',
+            'autoclose': True,
+        }
+
+        widgets = {
+            'comment': forms.Textarea,
+            'startdate': AdminDateWidget(),
+            'enddate': AdminDateWidget(),
+            'start_time': AdminTimeWidget(),
+            'end_time': AdminTimeWidget(),
+            'registration_closure':AdminSplitDateTime(),
+            'evaluation_closure':AdminSplitDateTime(),
+            }
+
+    def __init__(self,*args,**kwargs):
+        super(IndoorVirtualRaceForm, self).__init__(*args, **kwargs)
+        self.fields['sessionunit'].choices = [('min','minutes'),('m','meters')]
+
+    def clean(self):
+        cd = self.cleaned_data
+        timezone_str = cd['timezone']
+
+        start_time = cd['start_time']
+        if start_time is None:
+            raise forms.ValidationError(
+                    'Must have start time',
+                    code='missing_yparam1'
+                    )
         
+        start_date = cd['startdate']
+        startdatetime = datetime.datetime.combine(start_date,start_time)
+        startdatetime = pytz.timezone(timezone_str).localize(
+            startdatetime
+        )
+
+        end_time = cd['end_time']
+        if end_time is None:
+            raise forms.ValidationError(
+                'Must have end time',
+                code='missing endtime'
+                )
+            
+        end_date = cd['enddate']
+        enddatetime = datetime.datetime.combine(end_date,end_time)
+        enddatetime = pytz.timezone(timezone_str).localize(
+            enddatetime
+        )
+
+        registration_closure = cd['registration_closure']
+
+        registration_form = cd['registration_form']
+
+        try:
+            evaluation_closure = cd['evaluation_closure']
+        except KeyError:
+            evaluation_closure = enddatetime+datetime.timedelta(days=1)
+            cd['evaluation_closure'] = evaluation_closure
+
+        if registration_form == 'manual':
+            try:
+                registration_closure = pytz.timezone(
+                    timezone_str
+                ).localize(
+                    registration_closure.replace(tzinfo=None)
+                )
+            except AttributeError:
+                registration_closure = startdatetime
+        elif registration_form == 'windowstart':
+            registration_closure = startdatetime
+        elif registration_form == 'windowend':
+            registration_closure = enddatetime
+        else:
+            registration_closure = evaluation_closure
+
+
+        if registration_closure <= timezone.now():
+            raise forms.ValidationError("Registration Closure cannot be in the past")
+
+
+        if startdatetime > enddatetime:
+            raise forms.ValidationError("The Start of the Race Window should be before the End of the Race Window")
+
+
+        if cd['evaluation_closure'] <= enddatetime:
+            raise forms.ValidationError("Evaluation closure deadline should be after the Race Window closes")
+
+        if cd['evaluation_closure'] <= timezone.now():
+            raise forms.ValidationError("Evaluation closure cannot be in the past")
+        
+
+        return cd
+            
+    
 class VirtualRaceForm(ModelForm):
     course = forms.ModelChoiceField(queryset = GeoCourse.objects, empty_label=None)
     registration_closure = forms.SplitDateTimeField(widget=AdminSplitDateTime(),required=False)
@@ -2309,6 +2429,54 @@ class VirtualRaceResult(models.Model):
                 s = self.sex,
                 )
 
+# Virtual Race results (for keeping results when workouts are deleted)
+class IndoorVirtualRaceResult(models.Model):
+    boatclasses = (type for type in mytypes.workouttypes if type[0] in mytypes.otetypes)
+    userid = models.IntegerField(default=0)
+    teamname = models.CharField(max_length=80,verbose_name = 'Team Name',
+                                blank=True,null=True)
+    username = models.CharField(max_length=150)
+    workoutid = models.IntegerField(null=True)
+    weightcategory = models.CharField(default="hwt",max_length=10,
+                                      choices=weightcategories,
+                                      verbose_name='Weight Category')
+    race = models.ForeignKey(VirtualRace)
+    duration = models.TimeField(default=datetime.time(1,0))
+    distance = models.IntegerField(default=0)
+    boatclass = models.CharField(choices=boatclasses,
+                                   max_length=40,
+                                   default='rower',
+                                   verbose_name = 'Ergometer Class')
+    coursecompleted = models.BooleanField(default=False)
+    sex = models.CharField(default="not specified",
+                           max_length=30,
+                           choices=sexcategories,
+                           verbose_name='Gender')
+
+    age = models.IntegerField(null=True)
+
+    def __unicode__(self):
+        rr = Rower.objects.get(id=self.userid)
+        name = '{u1} {u2}'.format(
+            u1 = rr.user.first_name,
+            u2 = rr.user.last_name,
+            )
+        if self.teamname:
+            return u'Entry for {n} for "{r}" in {c} with {t} ({s})'.format(
+                n = name,
+                r = self.race,
+                t = self.teamname,
+                c = self.boatclass,
+                s = self.sex,
+            )
+        else:
+            return u'Entry for {n} for "{r}" in {c} ({s})'.format(
+                n = name,
+                r = self.race,
+                c = self.boatclass,
+                s = self.sex,
+                )
+
 
 class CourseTestResult(models.Model):
     userid = models.IntegerField(default=0)
@@ -2318,6 +2486,16 @@ class CourseTestResult(models.Model):
     distance = models.IntegerField(default=0)
     coursecompleted = models.BooleanField(default=False)
     
+class IndoorVirtualRaceResultForm(ModelForm):
+    class Meta:
+	model = IndoorVirtualRaceResult
+	fields = ['teamname','weightcategory','boatclass','age']
+
+
+    def __init__(self, *args, **kwargs):
+        super(IndoorVirtualRaceResultForm, self).__init__(*args, **kwargs)
+
+    
 class VirtualRaceResultForm(ModelForm):
     class Meta:
 	model = VirtualRaceResult