~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to ivle/database.py

  • Committer: Matt Giuca
  • Date: 2010-07-22 00:46:45 UTC
  • mto: This revision was merged to the branch mainline in revision 1818.
  • Revision ID: matt.giuca@gmail.com-20100722004645-giso3xsjm8o8rflf
Project page: Removed the space before the '*'.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# IVLE - Informatics Virtual Learning Environment
 
2
# Copyright (C) 2007-2009 The University of Melbourne
 
3
#
 
4
# This program is free software; you can redistribute it and/or modify
 
5
# it under the terms of the GNU General Public License as published by
 
6
# the Free Software Foundation; either version 2 of the License, or
 
7
# (at your option) any later version.
 
8
#
 
9
# This program is distributed in the hope that it will be useful,
 
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
# GNU General Public License for more details.
 
13
#
 
14
# You should have received a copy of the GNU General Public License
 
15
# along with this program; if not, write to the Free Software
 
16
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
17
 
 
18
# Author: Matt Giuca, Will Grant
 
19
 
 
20
"""Database utilities and content classes.
 
21
 
 
22
This module provides all of the classes which map to database tables.
 
23
It also provides miscellaneous utility functions for database interaction.
 
24
"""
 
25
 
 
26
import hashlib
 
27
import datetime
 
28
import os
 
29
import urlparse
 
30
import urllib
 
31
 
 
32
from storm.locals import create_database, Store, Int, Unicode, DateTime, \
 
33
                         Reference, ReferenceSet, Bool, Storm, Desc
 
34
from storm.expr import Select, Max
 
35
from storm.exceptions import NotOneError, IntegrityError
 
36
 
 
37
from ivle.worksheet.rst import rst
 
38
 
 
39
__all__ = ['get_store',
 
40
            'User',
 
41
            'Subject', 'Semester', 'Offering', 'Enrolment',
 
42
            'ProjectSet', 'Project', 'ProjectGroup', 'ProjectGroupMembership',
 
43
            'Assessed', 'ProjectSubmission', 'ProjectExtension',
 
44
            'Exercise', 'Worksheet', 'WorksheetExercise',
 
45
            'ExerciseSave', 'ExerciseAttempt',
 
46
            'TestCase', 'TestSuite', 'TestSuiteVar'
 
47
        ]
 
48
 
 
49
def _kwarg_init(self, **kwargs):
 
50
    for k,v in kwargs.items():
 
51
        if k.startswith('_') or not hasattr(self.__class__, k):
 
52
            raise TypeError("%s got an unexpected keyword argument '%s'"
 
53
                % (self.__class__.__name__, k))
 
54
        setattr(self, k, v)
 
55
 
 
56
def get_conn_string(config):
 
57
    """Create a Storm connection string to the IVLE database
 
58
 
 
59
    @param config: The IVLE configuration.
 
60
    """
 
61
 
 
62
    clusterstr = ''
 
63
    if config['database']['username']:
 
64
        clusterstr += config['database']['username']
 
65
        if config['database']['password']:
 
66
            clusterstr += ':' + config['database']['password']
 
67
        clusterstr += '@'
 
68
 
 
69
    host = config['database']['host'] or 'localhost'
 
70
    port = config['database']['port'] or 5432
 
71
 
 
72
    clusterstr += '%s:%d' % (host, port)
 
73
 
 
74
    return "postgres://%s/%s" % (clusterstr, config['database']['name'])
 
75
 
 
76
def get_store(config):
 
77
    """Create a Storm store connected to the IVLE database.
 
78
 
 
79
    @param config: The IVLE configuration.
 
80
    """
 
81
    return Store(create_database(get_conn_string(config)))
 
82
 
 
83
# USERS #
 
84
 
 
85
class User(Storm):
 
86
    """An IVLE user account."""
 
87
    __storm_table__ = "login"
 
88
 
 
89
    id = Int(primary=True, name="loginid")
 
90
    login = Unicode()
 
91
    passhash = Unicode()
 
92
    state = Unicode()
 
93
    admin = Bool()
 
94
    unixid = Int()
 
95
    nick = Unicode()
 
96
    pass_exp = DateTime()
 
97
    acct_exp = DateTime()
 
98
    last_login = DateTime()
 
99
    svn_pass = Unicode()
 
100
    email = Unicode()
 
101
    fullname = Unicode()
 
102
    studentid = Unicode()
 
103
    settings = Unicode()
 
104
 
 
105
    __init__ = _kwarg_init
 
106
 
 
107
    def __repr__(self):
 
108
        return "<%s '%s'>" % (type(self).__name__, self.login)
 
109
 
 
110
    def authenticate(self, password):
 
111
        """Validate a given password against this user.
 
112
 
 
113
        Returns True if the given password matches the password hash for this
 
114
        User, False if it doesn't match, and None if there is no hash for the
 
115
        user.
 
116
        """
 
117
        if self.passhash is None:
 
118
            return None
 
119
        return self.hash_password(password) == self.passhash
 
120
 
 
121
    @property
 
122
    def display_name(self):
 
123
        """Returns the "nice name" of the user or group."""
 
124
        return self.fullname
 
125
 
 
126
    @property
 
127
    def short_name(self):
 
128
        """Returns the database "identifier" name of the user or group."""
 
129
        return self.login
 
130
 
 
131
    @property
 
132
    def password_expired(self):
 
133
        fieldval = self.pass_exp
 
134
        return fieldval is not None and datetime.datetime.now() > fieldval
 
135
 
 
136
    @property
 
137
    def account_expired(self):
 
138
        fieldval = self.acct_exp
 
139
        return fieldval is not None and datetime.datetime.now() > fieldval
 
140
 
 
141
    @property
 
142
    def valid(self):
 
143
        return self.state == 'enabled' and not self.account_expired
 
144
 
 
145
    def _get_enrolments(self, justactive):
 
146
        return Store.of(self).find(Enrolment,
 
147
            Enrolment.user_id == self.id,
 
148
            (Enrolment.active == True) if justactive else True,
 
149
            Enrolment.offering_id == Offering.id,
 
150
            Offering.semester_id == Semester.id,
 
151
            Offering.subject_id == Subject.id).order_by(
 
152
                Desc(Semester.year),
 
153
                Desc(Semester.semester),
 
154
                Desc(Subject.code)
 
155
            )
 
156
 
 
157
    def _set_password(self, password):
 
158
        if password is None:
 
159
            self.passhash = None
 
160
        else:
 
161
            self.passhash = unicode(User.hash_password(password))
 
162
    password = property(fset=_set_password)
 
163
 
 
164
    @property
 
165
    def subjects(self):
 
166
        return Store.of(self).find(Subject,
 
167
            Enrolment.user_id == self.id,
 
168
            Enrolment.active == True,
 
169
            Offering.id == Enrolment.offering_id,
 
170
            Subject.id == Offering.subject_id).config(distinct=True)
 
171
 
 
172
    # TODO: Invitations should be listed too?
 
173
    def get_groups(self, offering=None):
 
174
        """Get groups of which this user is a member.
 
175
 
 
176
        @param offering: An optional offering to restrict the search to.
 
177
        """
 
178
        preds = [
 
179
            ProjectGroupMembership.user_id == self.id,
 
180
            ProjectGroup.id == ProjectGroupMembership.project_group_id,
 
181
        ]
 
182
        if offering:
 
183
            preds.extend([
 
184
                ProjectSet.offering_id == offering.id,
 
185
                ProjectGroup.project_set_id == ProjectSet.id,
 
186
            ])
 
187
        return Store.of(self).find(ProjectGroup, *preds)
 
188
 
 
189
    @property
 
190
    def groups(self):
 
191
        return self.get_groups()
 
192
 
 
193
    @property
 
194
    def active_enrolments(self):
 
195
        '''A sanely ordered list of the user's active enrolments.'''
 
196
        return self._get_enrolments(True)
 
197
 
 
198
    @property
 
199
    def enrolments(self):
 
200
        '''A sanely ordered list of all of the user's enrolments.'''
 
201
        return self._get_enrolments(False) 
 
202
 
 
203
    def get_projects(self, offering=None, active_only=True):
 
204
        """Find projects that the user can submit.
 
205
 
 
206
        This will include projects for offerings in which the user is
 
207
        enrolled, as long as the project is not in a project set which has
 
208
        groups (ie. if maximum number of group members is 0).
 
209
 
 
210
        @param active_only: Whether to only search active offerings.
 
211
        @param offering: An optional offering to restrict the search to.
 
212
        """
 
213
        return Store.of(self).find(Project,
 
214
            Project.project_set_id == ProjectSet.id,
 
215
            ProjectSet.max_students_per_group == None,
 
216
            ProjectSet.offering_id == Offering.id,
 
217
            (offering is None) or (Offering.id == offering.id),
 
218
            Semester.id == Offering.semester_id,
 
219
            (not active_only) or (Semester.state == u'current'),
 
220
            Enrolment.offering_id == Offering.id,
 
221
            Enrolment.user_id == self.id,
 
222
            Enrolment.active == True)
 
223
 
 
224
    @staticmethod
 
225
    def hash_password(password):
 
226
        """Hash a password with MD5."""
 
227
        return hashlib.md5(password).hexdigest()
 
228
 
 
229
    @classmethod
 
230
    def get_by_login(cls, store, login):
 
231
        """Find a user in a store by login name."""
 
232
        return store.find(cls, cls.login == unicode(login)).one()
 
233
 
 
234
    def get_svn_url(self, config):
 
235
        """Get the subversion repository URL for this user or group."""
 
236
        url = config['urls']['svn_addr']
 
237
        path = 'users/%s' % self.login
 
238
        return urlparse.urljoin(url, path)
 
239
 
 
240
    def get_permissions(self, user, config):
 
241
        """Determine privileges held by a user over this object.
 
242
 
 
243
        If the user requesting privileges is this user or an admin,
 
244
        they may do everything. Otherwise they may do nothing.
 
245
        """
 
246
        if user and user.admin or user is self:
 
247
            return set(['view_public', 'view', 'edit', 'submit_project'])
 
248
        else:
 
249
            return set(['view_public'])
 
250
 
 
251
# SUBJECTS AND ENROLMENTS #
 
252
 
 
253
class Subject(Storm):
 
254
    """A subject (or course) which is run in some semesters."""
 
255
 
 
256
    __storm_table__ = "subject"
 
257
 
 
258
    id = Int(primary=True, name="subjectid")
 
259
    code = Unicode(name="subj_code")
 
260
    name = Unicode(name="subj_name")
 
261
    short_name = Unicode(name="subj_short_name")
 
262
 
 
263
    offerings = ReferenceSet(id, 'Offering.subject_id')
 
264
 
 
265
    __init__ = _kwarg_init
 
266
 
 
267
    def __repr__(self):
 
268
        return "<%s '%s'>" % (type(self).__name__, self.short_name)
 
269
 
 
270
    def get_permissions(self, user, config):
 
271
        """Determine privileges held by a user over this object.
 
272
 
 
273
        If the user requesting privileges is an admin, they may edit.
 
274
        Otherwise they may only read.
 
275
        """
 
276
        perms = set()
 
277
        if user is not None:
 
278
            perms.add('view')
 
279
            if user.admin:
 
280
                perms.add('edit')
 
281
        return perms
 
282
 
 
283
    def active_offerings(self):
 
284
        """Find active offerings for this subject.
 
285
 
 
286
        Return a sequence of currently active offerings for this subject
 
287
        (offerings whose semester.state is "current"). There should be 0 or 1
 
288
        elements in this sequence, but it's possible there are more.
 
289
        """
 
290
        return self.offerings.find(Offering.semester_id == Semester.id,
 
291
                                   Semester.state == u'current')
 
292
 
 
293
    def offering_for_semester(self, year, semester):
 
294
        """Get the offering for the given year/semester, or None.
 
295
 
 
296
        @param year: A string representation of the year.
 
297
        @param semester: A string representation of the semester.
 
298
        """
 
299
        return self.offerings.find(Offering.semester_id == Semester.id,
 
300
                               Semester.year == unicode(year),
 
301
                               Semester.semester == unicode(semester)).one()
 
302
 
 
303
class Semester(Storm):
 
304
    """A semester in which subjects can be run."""
 
305
 
 
306
    __storm_table__ = "semester"
 
307
 
 
308
    id = Int(primary=True, name="semesterid")
 
309
    year = Unicode()
 
310
    semester = Unicode()
 
311
    state = Unicode()
 
312
 
 
313
    offerings = ReferenceSet(id, 'Offering.semester_id')
 
314
    enrolments = ReferenceSet(id,
 
315
                              'Offering.semester_id',
 
316
                              'Offering.id',
 
317
                              'Enrolment.offering_id')
 
318
 
 
319
    __init__ = _kwarg_init
 
320
 
 
321
    def __repr__(self):
 
322
        return "<%s %s/%s>" % (type(self).__name__, self.year, self.semester)
 
323
 
 
324
class Offering(Storm):
 
325
    """An offering of a subject in a particular semester."""
 
326
 
 
327
    __storm_table__ = "offering"
 
328
 
 
329
    id = Int(primary=True, name="offeringid")
 
330
    subject_id = Int(name="subject")
 
331
    subject = Reference(subject_id, Subject.id)
 
332
    semester_id = Int(name="semesterid")
 
333
    semester = Reference(semester_id, Semester.id)
 
334
    description = Unicode()
 
335
    url = Unicode()
 
336
    show_worksheet_marks = Bool()
 
337
    worksheet_cutoff = DateTime()
 
338
    groups_student_permissions = Unicode()
 
339
 
 
340
    enrolments = ReferenceSet(id, 'Enrolment.offering_id')
 
341
    members = ReferenceSet(id,
 
342
                           'Enrolment.offering_id',
 
343
                           'Enrolment.user_id',
 
344
                           'User.id')
 
345
    project_sets = ReferenceSet(id, 'ProjectSet.offering_id')
 
346
    projects = ReferenceSet(id,
 
347
                            'ProjectSet.offering_id',
 
348
                            'ProjectSet.id',
 
349
                            'Project.project_set_id')
 
350
 
 
351
    worksheets = ReferenceSet(id, 
 
352
        'Worksheet.offering_id', 
 
353
        order_by="seq_no"
 
354
    )
 
355
 
 
356
    __init__ = _kwarg_init
 
357
 
 
358
    def __repr__(self):
 
359
        return "<%s %r in %r>" % (type(self).__name__, self.subject,
 
360
                                  self.semester)
 
361
 
 
362
    def enrol(self, user, role=u'student'):
 
363
        """Enrol a user in this offering.
 
364
 
 
365
        Enrolments handle both the staff and student cases. The role controls
 
366
        the privileges granted by this enrolment.
 
367
        """
 
368
        enrolment = Store.of(self).find(Enrolment,
 
369
                               Enrolment.user_id == user.id,
 
370
                               Enrolment.offering_id == self.id).one()
 
371
 
 
372
        if enrolment is None:
 
373
            enrolment = Enrolment(user=user, offering=self)
 
374
            self.enrolments.add(enrolment)
 
375
 
 
376
        enrolment.active = True
 
377
        enrolment.role = role
 
378
 
 
379
    def unenrol(self, user):
 
380
        '''Unenrol a user from this offering.'''
 
381
        enrolment = Store.of(self).find(Enrolment,
 
382
                               Enrolment.user_id == user.id,
 
383
                               Enrolment.offering_id == self.id).one()
 
384
        Store.of(enrolment).remove(enrolment)
 
385
 
 
386
    def get_permissions(self, user, config):
 
387
        perms = set()
 
388
        if user is not None:
 
389
            enrolment = self.get_enrolment(user)
 
390
            if enrolment or user.admin:
 
391
                perms.add('view')
 
392
            if enrolment and enrolment.role == u'tutor':
 
393
                perms.add('view_project_submissions')
 
394
                # Site-specific policy on the role of tutors
 
395
                if config['policy']['tutors_can_enrol_students']:
 
396
                    perms.add('enrol')
 
397
                    perms.add('enrol_student')
 
398
                if config['policy']['tutors_can_edit_worksheets']:
 
399
                    perms.add('edit_worksheets')
 
400
                if config['policy']['tutors_can_admin_groups']:
 
401
                    perms.add('admin_groups')
 
402
            if (enrolment and enrolment.role in (u'lecturer')) or user.admin:
 
403
                perms.add('view_project_submissions')
 
404
                perms.add('admin_groups')
 
405
                perms.add('edit_worksheets')
 
406
                perms.add('view_worksheet_marks')
 
407
                perms.add('edit')           # Can edit projects & details
 
408
                perms.add('enrol')          # Can see enrolment screen at all
 
409
                perms.add('enrol_student')  # Can enrol students
 
410
                perms.add('enrol_tutor')    # Can enrol tutors
 
411
            if user.admin:
 
412
                perms.add('enrol_lecturer') # Can enrol lecturers
 
413
        return perms
 
414
 
 
415
    def get_enrolment(self, user):
 
416
        """Find the user's enrolment in this offering."""
 
417
        try:
 
418
            enrolment = self.enrolments.find(user=user).one()
 
419
        except NotOneError:
 
420
            enrolment = None
 
421
 
 
422
        return enrolment
 
423
 
 
424
    def get_members_by_role(self, role):
 
425
        return Store.of(self).find(User,
 
426
                Enrolment.user_id == User.id,
 
427
                Enrolment.offering_id == self.id,
 
428
                Enrolment.role == role
 
429
                ).order_by(User.login)
 
430
 
 
431
    @property
 
432
    def students(self):
 
433
        return self.get_members_by_role(u'student')
 
434
 
 
435
    def get_open_projects_for_user(self, user):
 
436
        """Find all projects currently open to submissions by a user."""
 
437
        # XXX: Respect extensions.
 
438
        return self.projects.find(Project.deadline > datetime.datetime.now())
 
439
 
 
440
    def has_worksheet_cutoff_passed(self, user):
 
441
        """Check whether the worksheet cutoff has passed.
 
442
        A user is required, in case we support extensions.
 
443
        """
 
444
        if self.worksheet_cutoff is None:
 
445
            return False
 
446
        else:
 
447
            return self.worksheet_cutoff < datetime.datetime.now()
 
448
 
 
449
    def clone_worksheets(self, source):
 
450
        """Clone all worksheets from the specified source to this offering."""
 
451
        import ivle.worksheet.utils
 
452
        for worksheet in source.worksheets:
 
453
            newws = Worksheet()
 
454
            newws.seq_no = worksheet.seq_no
 
455
            newws.identifier = worksheet.identifier
 
456
            newws.name = worksheet.name
 
457
            newws.assessable = worksheet.assessable
 
458
            newws.published = worksheet.published
 
459
            newws.data = worksheet.data
 
460
            newws.format = worksheet.format
 
461
            newws.offering = self
 
462
            Store.of(self).add(newws)
 
463
            ivle.worksheet.utils.update_exerciselist(newws)
 
464
 
 
465
 
 
466
class Enrolment(Storm):
 
467
    """An enrolment of a user in an offering.
 
468
 
 
469
    This represents the roles of both staff and students.
 
470
    """
 
471
 
 
472
    __storm_table__ = "enrolment"
 
473
    __storm_primary__ = "user_id", "offering_id"
 
474
 
 
475
    user_id = Int(name="loginid")
 
476
    user = Reference(user_id, User.id)
 
477
    offering_id = Int(name="offeringid")
 
478
    offering = Reference(offering_id, Offering.id)
 
479
    role = Unicode()
 
480
    notes = Unicode()
 
481
    active = Bool()
 
482
 
 
483
    @property
 
484
    def groups(self):
 
485
        return Store.of(self).find(ProjectGroup,
 
486
                ProjectSet.offering_id == self.offering.id,
 
487
                ProjectGroup.project_set_id == ProjectSet.id,
 
488
                ProjectGroupMembership.project_group_id == ProjectGroup.id,
 
489
                ProjectGroupMembership.user_id == self.user.id)
 
490
 
 
491
    __init__ = _kwarg_init
 
492
 
 
493
    def __repr__(self):
 
494
        return "<%s %r in %r>" % (type(self).__name__, self.user,
 
495
                                  self.offering)
 
496
 
 
497
    def get_permissions(self, user, config):
 
498
        # A user can edit any enrolment that they could have created.
 
499
        perms = set()
 
500
        if ('enrol_' + str(self.role)) in self.offering.get_permissions(
 
501
            user, config):
 
502
            perms.add('edit')
 
503
        return perms
 
504
 
 
505
    def delete(self):
 
506
        """Delete this enrolment."""
 
507
        Store.of(self).remove(self)
 
508
 
 
509
 
 
510
# PROJECTS #
 
511
 
 
512
class ProjectSet(Storm):
 
513
    """A set of projects that share common groups.
 
514
 
 
515
    Each student project group is attached to a project set. The group is
 
516
    valid for all projects in the group's set.
 
517
    """
 
518
 
 
519
    __storm_table__ = "project_set"
 
520
 
 
521
    id = Int(name="projectsetid", primary=True)
 
522
    offering_id = Int(name="offeringid")
 
523
    offering = Reference(offering_id, Offering.id)
 
524
    max_students_per_group = Int()
 
525
 
 
526
    projects = ReferenceSet(id, 'Project.project_set_id')
 
527
    project_groups = ReferenceSet(id, 'ProjectGroup.project_set_id')
 
528
 
 
529
    __init__ = _kwarg_init
 
530
 
 
531
    def __repr__(self):
 
532
        return "<%s %d in %r>" % (type(self).__name__, self.id,
 
533
                                  self.offering)
 
534
 
 
535
    def get_permissions(self, user, config):
 
536
        return self.offering.get_permissions(user, config)
 
537
 
 
538
    def get_groups_for_user(self, user):
 
539
        """List all groups in this offering of which the user is a member."""
 
540
        assert self.is_group
 
541
        return Store.of(self).find(
 
542
            ProjectGroup,
 
543
            ProjectGroupMembership.user_id == user.id,
 
544
            ProjectGroupMembership.project_group_id == ProjectGroup.id,
 
545
            ProjectGroup.project_set_id == self.id)
 
546
 
 
547
    def get_submission_principal(self, user):
 
548
        """Get the principal on behalf of which the user can submit.
 
549
 
 
550
        If this is a solo project set, the given user is returned. If
 
551
        the user is a member of exactly one group, all the group is
 
552
        returned. Otherwise, None is returned.
 
553
        """
 
554
        if self.is_group:
 
555
            groups = self.get_groups_for_user(user)
 
556
            if groups.count() == 1:
 
557
                return groups.one()
 
558
            else:
 
559
                return None
 
560
        else:
 
561
            return user
 
562
 
 
563
    @property
 
564
    def is_group(self):
 
565
        return self.max_students_per_group is not None
 
566
 
 
567
    @property
 
568
    def assigned(self):
 
569
        """Get the entities (groups or users) assigned to submit this project.
 
570
 
 
571
        This will be a Storm ResultSet.
 
572
        """
 
573
        #If its a solo project, return everyone in offering
 
574
        if self.is_group:
 
575
            return self.project_groups
 
576
        else:
 
577
            return self.offering.students
 
578
 
 
579
class DeadlinePassed(Exception):
 
580
    """An exception indicating that a project cannot be submitted because the
 
581
    deadline has passed."""
 
582
    def __init__(self):
 
583
        pass
 
584
    def __str__(self):
 
585
        return "The project deadline has passed"
 
586
 
 
587
class Project(Storm):
 
588
    """A student project for which submissions can be made."""
 
589
 
 
590
    __storm_table__ = "project"
 
591
 
 
592
    id = Int(name="projectid", primary=True)
 
593
    name = Unicode()
 
594
    short_name = Unicode()
 
595
    synopsis = Unicode()
 
596
    url = Unicode()
 
597
    project_set_id = Int(name="projectsetid")
 
598
    project_set = Reference(project_set_id, ProjectSet.id)
 
599
    deadline = DateTime()
 
600
 
 
601
    assesseds = ReferenceSet(id, 'Assessed.project_id')
 
602
    submissions = ReferenceSet(id,
 
603
                               'Assessed.project_id',
 
604
                               'Assessed.id',
 
605
                               'ProjectSubmission.assessed_id')
 
606
 
 
607
    __init__ = _kwarg_init
 
608
 
 
609
    def __repr__(self):
 
610
        return "<%s '%s' in %r>" % (type(self).__name__, self.short_name,
 
611
                                  self.project_set.offering)
 
612
 
 
613
    def can_submit(self, principal, user, late=False):
 
614
        """
 
615
        @param late: If True, does not take the deadline into account.
 
616
        """
 
617
        return (self in principal.get_projects() and
 
618
                (late or not self.has_deadline_passed(user)))
 
619
 
 
620
    def submit(self, principal, path, revision, who, late=False):
 
621
        """Submit a Subversion path and revision to a project.
 
622
 
 
623
        @param principal: The owner of the Subversion repository, and the
 
624
                          entity on behalf of whom the submission is being made
 
625
        @param path: A path within that repository to submit.
 
626
        @param revision: The revision of that path to submit.
 
627
        @param who: The user who is actually making the submission.
 
628
        @param late: If True, will not raise a DeadlinePassed exception even
 
629
            after the deadline. (Default False.)
 
630
        """
 
631
 
 
632
        if not self.can_submit(principal, who, late=late):
 
633
            raise DeadlinePassed()
 
634
 
 
635
        a = Assessed.get(Store.of(self), principal, self)
 
636
        ps = ProjectSubmission()
 
637
        # Raise SubmissionError if the path is illegal
 
638
        ps.path = ProjectSubmission.test_and_normalise_path(path)
 
639
        ps.revision = revision
 
640
        ps.date_submitted = datetime.datetime.now()
 
641
        ps.assessed = a
 
642
        ps.submitter = who
 
643
 
 
644
        return ps
 
645
 
 
646
    def get_permissions(self, user, config):
 
647
        return self.project_set.offering.get_permissions(user, config)
 
648
 
 
649
    @property
 
650
    def latest_submissions(self):
 
651
        """Return the latest submission for each Assessed."""
 
652
        return Store.of(self).find(ProjectSubmission,
 
653
            Assessed.project_id == self.id,
 
654
            ProjectSubmission.assessed_id == Assessed.id,
 
655
            ProjectSubmission.date_submitted == Select(
 
656
                    Max(ProjectSubmission.date_submitted),
 
657
                    ProjectSubmission.assessed_id == Assessed.id,
 
658
                    tables=ProjectSubmission
 
659
            )
 
660
        )
 
661
 
 
662
    def has_deadline_passed(self, user):
 
663
        """Check whether the deadline has passed."""
 
664
        # XXX: Need to respect extensions.
 
665
        return self.deadline < datetime.datetime.now()
 
666
 
 
667
    def get_submissions_for_principal(self, principal):
 
668
        """Fetch a ResultSet of all submissions by a particular principal."""
 
669
        assessed = Assessed.get(Store.of(self), principal, self)
 
670
        if assessed is None:
 
671
            return
 
672
        return assessed.submissions
 
673
 
 
674
    @property
 
675
    def can_delete(self):
 
676
        """Can only delete if there are no submissions."""
 
677
        return self.submissions.count() == 0
 
678
 
 
679
    def delete(self):
 
680
        """Delete the project. Fails if can_delete is False."""
 
681
        if not self.can_delete:
 
682
            raise IntegrityError()
 
683
        for assessed in self.assesseds:
 
684
            assessed.delete()
 
685
        Store.of(self).remove(self)
 
686
 
 
687
class ProjectGroup(Storm):
 
688
    """A group of students working together on a project."""
 
689
 
 
690
    __storm_table__ = "project_group"
 
691
 
 
692
    id = Int(name="groupid", primary=True)
 
693
    name = Unicode(name="groupnm")
 
694
    project_set_id = Int(name="projectsetid")
 
695
    project_set = Reference(project_set_id, ProjectSet.id)
 
696
    nick = Unicode()
 
697
    created_by_id = Int(name="createdby")
 
698
    created_by = Reference(created_by_id, User.id)
 
699
    epoch = DateTime()
 
700
 
 
701
    members = ReferenceSet(id,
 
702
                           "ProjectGroupMembership.project_group_id",
 
703
                           "ProjectGroupMembership.user_id",
 
704
                           "User.id")
 
705
 
 
706
    __init__ = _kwarg_init
 
707
 
 
708
    def __repr__(self):
 
709
        return "<%s %s in %r>" % (type(self).__name__, self.name,
 
710
                                  self.project_set.offering)
 
711
 
 
712
    @property
 
713
    def display_name(self):
 
714
        """Returns the "nice name" of the user or group."""
 
715
        return self.nick
 
716
 
 
717
    @property
 
718
    def short_name(self):
 
719
        """Returns the database "identifier" name of the user or group."""
 
720
        return self.name
 
721
 
 
722
    def get_projects(self, offering=None, active_only=True):
 
723
        '''Find projects that the group can submit.
 
724
 
 
725
        This will include projects in the project set which owns this group,
 
726
        unless the project set disallows groups (in which case none will be
 
727
        returned).
 
728
 
 
729
        @param active_only: Whether to only search active offerings.
 
730
        @param offering: An optional offering to restrict the search to.
 
731
        '''
 
732
        return Store.of(self).find(Project,
 
733
            Project.project_set_id == ProjectSet.id,
 
734
            ProjectSet.id == self.project_set.id,
 
735
            ProjectSet.max_students_per_group != None,
 
736
            ProjectSet.offering_id == Offering.id,
 
737
            (offering is None) or (Offering.id == offering.id),
 
738
            Semester.id == Offering.semester_id,
 
739
            (not active_only) or (Semester.state == u'current'))
 
740
 
 
741
    def get_svn_url(self, config):
 
742
        """Get the subversion repository URL for this user or group."""
 
743
        url = config['urls']['svn_addr']
 
744
        path = 'groups/%s_%s_%s_%s' % (
 
745
                self.project_set.offering.subject.short_name,
 
746
                self.project_set.offering.semester.year,
 
747
                self.project_set.offering.semester.semester,
 
748
                self.name
 
749
                )
 
750
        return urlparse.urljoin(url, path)
 
751
 
 
752
    def get_permissions(self, user, config):
 
753
        if user.admin or user in self.members:
 
754
            return set(['submit_project'])
 
755
        else:
 
756
            return set()
 
757
 
 
758
class ProjectGroupMembership(Storm):
 
759
    """A student's membership in a project group."""
 
760
 
 
761
    __storm_table__ = "group_member"
 
762
    __storm_primary__ = "user_id", "project_group_id"
 
763
 
 
764
    user_id = Int(name="loginid")
 
765
    user = Reference(user_id, User.id)
 
766
    project_group_id = Int(name="groupid")
 
767
    project_group = Reference(project_group_id, ProjectGroup.id)
 
768
 
 
769
    __init__ = _kwarg_init
 
770
 
 
771
    def __repr__(self):
 
772
        return "<%s %r in %r>" % (type(self).__name__, self.user,
 
773
                                  self.project_group)
 
774
 
 
775
class Assessed(Storm):
 
776
    """A composite of a user or group combined with a project.
 
777
 
 
778
    Each project submission and extension refers to an Assessed. It is the
 
779
    sole specifier of the repository and project.
 
780
    """
 
781
 
 
782
    __storm_table__ = "assessed"
 
783
 
 
784
    id = Int(name="assessedid", primary=True)
 
785
    user_id = Int(name="loginid")
 
786
    user = Reference(user_id, User.id)
 
787
    project_group_id = Int(name="groupid")
 
788
    project_group = Reference(project_group_id, ProjectGroup.id)
 
789
 
 
790
    project_id = Int(name="projectid")
 
791
    project = Reference(project_id, Project.id)
 
792
 
 
793
    extensions = ReferenceSet(id, 'ProjectExtension.assessed_id')
 
794
    submissions = ReferenceSet(
 
795
        id, 'ProjectSubmission.assessed_id', order_by='date_submitted')
 
796
 
 
797
    def __repr__(self):
 
798
        return "<%s %r in %r>" % (type(self).__name__,
 
799
            self.user or self.project_group, self.project)
 
800
 
 
801
    @property
 
802
    def is_group(self):
 
803
        """True if the Assessed is a group, False if it is a user."""
 
804
        return self.project_group is not None
 
805
 
 
806
    @property
 
807
    def principal(self):
 
808
        return self.project_group or self.user
 
809
 
 
810
    @property
 
811
    def checkout_location(self):
 
812
        """Returns the location of the Subversion workspace for this piece of
 
813
        assessment, relative to each group member's home directory."""
 
814
        subjectname = self.project.project_set.offering.subject.short_name
 
815
        if self.is_group:
 
816
            checkout_dir_name = self.principal.short_name
 
817
        else:
 
818
            checkout_dir_name = "mywork"
 
819
        return subjectname + "/" + checkout_dir_name
 
820
 
 
821
    @classmethod
 
822
    def get(cls, store, principal, project):
 
823
        """Find or create an Assessed for the given user or group and project.
 
824
 
 
825
        @param principal: The user or group.
 
826
        @param project: The project.
 
827
        """
 
828
        t = type(principal)
 
829
        if t not in (User, ProjectGroup):
 
830
            raise AssertionError('principal must be User or ProjectGroup')
 
831
 
 
832
        a = store.find(cls,
 
833
            (t is User) or (cls.project_group_id == principal.id),
 
834
            (t is ProjectGroup) or (cls.user_id == principal.id),
 
835
            cls.project_id == project.id).one()
 
836
 
 
837
        if a is None:
 
838
            a = cls()
 
839
            if t is User:
 
840
                a.user = principal
 
841
            else:
 
842
                a.project_group = principal
 
843
            a.project = project
 
844
            store.add(a)
 
845
 
 
846
        return a
 
847
 
 
848
    def delete(self):
 
849
        """Delete the assessed. Fails if there are any submissions. Deletes
 
850
        extensions."""
 
851
        if self.submissions.count() > 0:
 
852
            raise IntegrityError()
 
853
        for extension in self.extensions:
 
854
            extension.delete()
 
855
        Store.of(self).remove(self)
 
856
 
 
857
class ProjectExtension(Storm):
 
858
    """An extension granted to a user or group on a particular project.
 
859
 
 
860
    The user or group and project are specified by the Assessed.
 
861
    """
 
862
 
 
863
    __storm_table__ = "project_extension"
 
864
 
 
865
    id = Int(name="extensionid", primary=True)
 
866
    assessed_id = Int(name="assessedid")
 
867
    assessed = Reference(assessed_id, Assessed.id)
 
868
    deadline = DateTime()
 
869
    approver_id = Int(name="approver")
 
870
    approver = Reference(approver_id, User.id)
 
871
    notes = Unicode()
 
872
 
 
873
    def delete(self):
 
874
        """Delete the extension."""
 
875
        Store.of(self).remove(self)
 
876
 
 
877
class SubmissionError(Exception):
 
878
    """Denotes a validation error during submission."""
 
879
    pass
 
880
 
 
881
class ProjectSubmission(Storm):
 
882
    """A submission from a user or group repository to a particular project.
 
883
 
 
884
    The content of a submission is a single path and revision inside a
 
885
    repository. The repository is that owned by the submission's user and
 
886
    group, while the path and revision are explicit.
 
887
 
 
888
    The user or group and project are specified by the Assessed.
 
889
    """
 
890
 
 
891
    __storm_table__ = "project_submission"
 
892
 
 
893
    id = Int(name="submissionid", primary=True)
 
894
    assessed_id = Int(name="assessedid")
 
895
    assessed = Reference(assessed_id, Assessed.id)
 
896
    path = Unicode()
 
897
    revision = Int()
 
898
    submitter_id = Int(name="submitter")
 
899
    submitter = Reference(submitter_id, User.id)
 
900
    date_submitted = DateTime()
 
901
 
 
902
    def get_verify_url(self, user):
 
903
        """Get the URL for verifying this submission, within the account of
 
904
        the given user."""
 
905
        # If this is a solo project, then self.path will be prefixed with the
 
906
        # subject name. Remove the first path segment.
 
907
        submitpath = self.path[1:] if self.path[:1] == '/' else self.path
 
908
        if not self.assessed.is_group:
 
909
            if '/' in submitpath:
 
910
                submitpath = submitpath.split('/', 1)[1]
 
911
            else:
 
912
                submitpath = ''
 
913
        return "/files/%s/%s/%s?r=%d" % (user.login,
 
914
            self.assessed.checkout_location, submitpath, self.revision)
 
915
 
 
916
    def get_svn_url(self, config):
 
917
        """Get subversion URL for this submission"""
 
918
        princ = self.assessed.principal
 
919
        base = princ.get_svn_url(config)
 
920
        if self.path.startswith(os.sep):
 
921
            return os.path.join(base,
 
922
                    urllib.quote(self.path[1:].encode('utf-8')))
 
923
        else:
 
924
            return os.path.join(base, urllib.quote(self.path.encode('utf-8')))
 
925
 
 
926
    def get_svn_export_command(self, req):
 
927
        """Returns a Unix shell command to export a submission"""
 
928
        svn_url = self.get_svn_url(req.config)
 
929
        username = (req.user.login if req.user.login.isalnum() else
 
930
                "'%s'"%req.user.login)
 
931
        export_dir = self.assessed.principal.short_name
 
932
        return "svn export --username %s -r%d '%s' %s"%(req.user.login,
 
933
                self.revision, svn_url, export_dir)
 
934
 
 
935
    @staticmethod
 
936
    def test_and_normalise_path(path):
 
937
        """Test that path is valid, and normalise it. This prevents possible
 
938
        injections using malicious paths.
 
939
        Returns the updated path, if successful.
 
940
        Raises SubmissionError if invalid.
 
941
        """
 
942
        # Ensure the path is absolute to prevent being tacked onto working
 
943
        # directories.
 
944
        # Prevent '\n' because it will break all sorts of things.
 
945
        # Prevent '[' and ']' because they can be used to inject into the
 
946
        # svn.conf.
 
947
        # Normalise to avoid resulting in ".." path segments.
 
948
        if not os.path.isabs(path):
 
949
            raise SubmissionError("Path is not absolute")
 
950
        if any(c in path for c in "\n[]"):
 
951
            raise SubmissionError("Path must not contain '\\n', '[' or ']'")
 
952
        return os.path.normpath(path)
 
953
 
 
954
    @property
 
955
    def late(self):
 
956
        """True if the project was submitted late."""
 
957
        return self.days_late > 0
 
958
 
 
959
    @property
 
960
    def days_late(self):
 
961
        """The number of days the project was submitted late (rounded up), or
 
962
        0 if on-time."""
 
963
        # XXX: Need to respect extensions.
 
964
        return max(0,
 
965
            (self.date_submitted - self.assessed.project.deadline).days + 1)
 
966
 
 
967
# WORKSHEETS AND EXERCISES #
 
968
 
 
969
class Exercise(Storm):
 
970
    """An exercise for students to complete in a worksheet.
 
971
 
 
972
    An exercise may be present in any number of worksheets.
 
973
    """
 
974
 
 
975
    __storm_table__ = "exercise"
 
976
    id = Unicode(primary=True, name="identifier")
 
977
    name = Unicode()
 
978
    description = Unicode()
 
979
    _description_xhtml_cache = Unicode(name='description_xhtml_cache')
 
980
    partial = Unicode()
 
981
    solution = Unicode()
 
982
    include = Unicode()
 
983
    num_rows = Int()
 
984
 
 
985
    worksheet_exercises =  ReferenceSet(id,
 
986
        'WorksheetExercise.exercise_id')
 
987
 
 
988
    worksheets = ReferenceSet(id,
 
989
        'WorksheetExercise.exercise_id',
 
990
        'WorksheetExercise.worksheet_id',
 
991
        'Worksheet.id'
 
992
    )
 
993
 
 
994
    test_suites = ReferenceSet(id, 
 
995
        'TestSuite.exercise_id',
 
996
        order_by='seq_no')
 
997
 
 
998
    __init__ = _kwarg_init
 
999
 
 
1000
    def __repr__(self):
 
1001
        return "<%s %s>" % (type(self).__name__, self.name)
 
1002
 
 
1003
    def get_permissions(self, user, config):
 
1004
        return self.global_permissions(user, config)
 
1005
 
 
1006
    @staticmethod
 
1007
    def global_permissions(user, config):
 
1008
        """Gets the set of permissions this user has over *all* exercises.
 
1009
        This is used to determine who may view the exercises list, and create
 
1010
        new exercises."""
 
1011
        perms = set()
 
1012
        roles = set()
 
1013
        if user is not None:
 
1014
            if user.admin:
 
1015
                perms.add('edit')
 
1016
                perms.add('view')
 
1017
            elif u'lecturer' in set((e.role for e in user.active_enrolments)):
 
1018
                perms.add('edit')
 
1019
                perms.add('view')
 
1020
            elif (config['policy']['tutors_can_edit_worksheets']
 
1021
            and u'tutor' in set((e.role for e in user.active_enrolments))):
 
1022
                # Site-specific policy on the role of tutors
 
1023
                perms.add('edit')
 
1024
                perms.add('view')
 
1025
 
 
1026
        return perms
 
1027
 
 
1028
    def _cache_description_xhtml(self, invalidate=False):
 
1029
        # Don't regenerate an existing cache unless forced.
 
1030
        if self._description_xhtml_cache is not None and not invalidate:
 
1031
            return
 
1032
 
 
1033
        if self.description:
 
1034
            self._description_xhtml_cache = rst(self.description)
 
1035
        else:
 
1036
            self._description_xhtml_cache = None
 
1037
 
 
1038
    @property
 
1039
    def description_xhtml(self):
 
1040
        """The XHTML exercise description, converted from reStructuredText."""
 
1041
        self._cache_description_xhtml()
 
1042
        return self._description_xhtml_cache
 
1043
 
 
1044
    def set_description(self, description):
 
1045
        self.description = description
 
1046
        self._cache_description_xhtml(invalidate=True)
 
1047
 
 
1048
    def delete(self):
 
1049
        """Deletes the exercise, providing it has no associated worksheets."""
 
1050
        if (self.worksheet_exercises.count() > 0):
 
1051
            raise IntegrityError()
 
1052
        for suite in self.test_suites:
 
1053
            suite.delete()
 
1054
        Store.of(self).remove(self)
 
1055
 
 
1056
class Worksheet(Storm):
 
1057
    """A worksheet with exercises for students to complete.
 
1058
 
 
1059
    Worksheets are owned by offerings.
 
1060
    """
 
1061
 
 
1062
    __storm_table__ = "worksheet"
 
1063
 
 
1064
    id = Int(primary=True, name="worksheetid")
 
1065
    offering_id = Int(name="offeringid")
 
1066
    identifier = Unicode()
 
1067
    name = Unicode()
 
1068
    assessable = Bool()
 
1069
    published = Bool()
 
1070
    data = Unicode()
 
1071
    _data_xhtml_cache = Unicode(name='data_xhtml_cache')
 
1072
    seq_no = Int()
 
1073
    format = Unicode()
 
1074
 
 
1075
    attempts = ReferenceSet(id, "ExerciseAttempt.worksheetid")
 
1076
    offering = Reference(offering_id, 'Offering.id')
 
1077
 
 
1078
    all_worksheet_exercises = ReferenceSet(id,
 
1079
        'WorksheetExercise.worksheet_id')
 
1080
 
 
1081
    # Use worksheet_exercises to get access to the *active* WorksheetExercise
 
1082
    # objects binding worksheets to exercises. This is required to access the
 
1083
    # "optional" field.
 
1084
 
 
1085
    @property
 
1086
    def worksheet_exercises(self):
 
1087
        return self.all_worksheet_exercises.find(active=True)
 
1088
 
 
1089
    __init__ = _kwarg_init
 
1090
 
 
1091
    def __repr__(self):
 
1092
        return "<%s %s>" % (type(self).__name__, self.name)
 
1093
 
 
1094
    def remove_all_exercises(self):
 
1095
        """Remove all exercises from this worksheet.
 
1096
 
 
1097
        This does not delete the exercises themselves. It just removes them
 
1098
        from the worksheet.
 
1099
        """
 
1100
        store = Store.of(self)
 
1101
        for ws_ex in self.all_worksheet_exercises:
 
1102
            if ws_ex.saves.count() > 0 or ws_ex.attempts.count() > 0:
 
1103
                raise IntegrityError()
 
1104
        store.find(WorksheetExercise,
 
1105
            WorksheetExercise.worksheet == self).remove()
 
1106
 
 
1107
    def get_permissions(self, user, config):
 
1108
        offering_perms = self.offering.get_permissions(user, config)
 
1109
 
 
1110
        perms = set()
 
1111
 
 
1112
        # Anybody who can view an offering can view a published
 
1113
        # worksheet.
 
1114
        if 'view' in offering_perms and self.published:
 
1115
            perms.add('view')
 
1116
 
 
1117
        # Any worksheet editors can both view and edit.
 
1118
        if 'edit_worksheets' in offering_perms:
 
1119
            perms.add('view')
 
1120
            perms.add('edit')
 
1121
 
 
1122
        return perms
 
1123
 
 
1124
    def _cache_data_xhtml(self, invalidate=False):
 
1125
        # Don't regenerate an existing cache unless forced.
 
1126
        if self._data_xhtml_cache is not None and not invalidate:
 
1127
            return
 
1128
 
 
1129
        if self.format == u'rst':
 
1130
            self._data_xhtml_cache = rst(self.data)
 
1131
        else:
 
1132
            self._data_xhtml_cache = None
 
1133
 
 
1134
    @property
 
1135
    def data_xhtml(self):
 
1136
        """The XHTML of this worksheet, converted from rST if required."""
 
1137
        # Update the rST -> XHTML cache, if required.
 
1138
        self._cache_data_xhtml()
 
1139
 
 
1140
        if self.format == u'rst':
 
1141
            return self._data_xhtml_cache
 
1142
        else:
 
1143
            return self.data
 
1144
 
 
1145
    def set_data(self, data):
 
1146
        self.data = data
 
1147
        self._cache_data_xhtml(invalidate=True)
 
1148
 
 
1149
    def delete(self):
 
1150
        """Deletes the worksheet, provided it has no attempts on any exercises.
 
1151
 
 
1152
        Returns True if delete succeeded, or False if this worksheet has
 
1153
        attempts attached."""
 
1154
        for ws_ex in self.all_worksheet_exercises:
 
1155
            if ws_ex.saves.count() > 0 or ws_ex.attempts.count() > 0:
 
1156
                raise IntegrityError()
 
1157
 
 
1158
        self.remove_all_exercises()
 
1159
        Store.of(self).remove(self)
 
1160
 
 
1161
class WorksheetExercise(Storm):
 
1162
    """A link between a worksheet and one of its exercises.
 
1163
 
 
1164
    These may be marked optional, in which case the exercise does not count
 
1165
    for marking purposes. The sequence number is used to order the worksheet
 
1166
    ToC.
 
1167
    """
 
1168
 
 
1169
    __storm_table__ = "worksheet_exercise"
 
1170
 
 
1171
    id = Int(primary=True, name="ws_ex_id")
 
1172
 
 
1173
    worksheet_id = Int(name="worksheetid")
 
1174
    worksheet = Reference(worksheet_id, Worksheet.id)
 
1175
    exercise_id = Unicode(name="exerciseid")
 
1176
    exercise = Reference(exercise_id, Exercise.id)
 
1177
    optional = Bool()
 
1178
    active = Bool()
 
1179
    seq_no = Int()
 
1180
 
 
1181
    saves = ReferenceSet(id, "ExerciseSave.ws_ex_id")
 
1182
    attempts = ReferenceSet(id, "ExerciseAttempt.ws_ex_id")
 
1183
 
 
1184
    __init__ = _kwarg_init
 
1185
 
 
1186
    def __repr__(self):
 
1187
        return "<%s %s in %s>" % (type(self).__name__, self.exercise.name,
 
1188
                                  self.worksheet.identifier)
 
1189
 
 
1190
    def get_permissions(self, user, config):
 
1191
        return self.worksheet.get_permissions(user, config)
 
1192
 
 
1193
 
 
1194
class ExerciseSave(Storm):
 
1195
    """A potential exercise solution submitted by a user for storage.
 
1196
 
 
1197
    This is not an actual tested attempt at an exercise, it's just a save of
 
1198
    the editing session.
 
1199
    """
 
1200
 
 
1201
    __storm_table__ = "exercise_save"
 
1202
    __storm_primary__ = "ws_ex_id", "user_id"
 
1203
 
 
1204
    ws_ex_id = Int(name="ws_ex_id")
 
1205
    worksheet_exercise = Reference(ws_ex_id, "WorksheetExercise.id")
 
1206
 
 
1207
    user_id = Int(name="loginid")
 
1208
    user = Reference(user_id, User.id)
 
1209
    date = DateTime()
 
1210
    text = Unicode()
 
1211
 
 
1212
    __init__ = _kwarg_init
 
1213
 
 
1214
    def __repr__(self):
 
1215
        return "<%s %s by %s at %s>" % (type(self).__name__,
 
1216
            self.worksheet_exercise.exercise.name, self.user.login,
 
1217
            self.date.strftime("%c"))
 
1218
 
 
1219
class ExerciseAttempt(ExerciseSave):
 
1220
    """An attempt at solving an exercise.
 
1221
 
 
1222
    This is a special case of ExerciseSave, used when the user submits a
 
1223
    candidate solution. Like an ExerciseSave, it constitutes exercise solution
 
1224
    data.
 
1225
 
 
1226
    In addition, it contains information about the result of the submission:
 
1227
 
 
1228
     - complete - True if this submission was successful, rendering this
 
1229
                  exercise complete for this user in this worksheet.
 
1230
     - active   - True if this submission is "active" (usually true).
 
1231
                  Submissions may be de-activated by privileged users for
 
1232
                  special reasons, and then they won't count (either as a
 
1233
                  penalty or success), but will still be stored.
 
1234
    """
 
1235
 
 
1236
    __storm_table__ = "exercise_attempt"
 
1237
    __storm_primary__ = "ws_ex_id", "user_id", "date"
 
1238
 
 
1239
    # The "text" field is the same but has a different name in the DB table
 
1240
    # for some reason.
 
1241
    text = Unicode(name="attempt")
 
1242
    complete = Bool()
 
1243
    active = Bool()
 
1244
 
 
1245
    def get_permissions(self, user, config):
 
1246
        return set(['view']) if user is self.user else set()
 
1247
 
 
1248
class TestSuite(Storm):
 
1249
    """A container to group an exercise's test cases.
 
1250
 
 
1251
    The test suite contains some information on how to test. The function to
 
1252
    test, variables to set and stdin data are stored here.
 
1253
    """
 
1254
 
 
1255
    __storm_table__ = "test_suite"
 
1256
    __storm_primary__ = "exercise_id", "suiteid"
 
1257
 
 
1258
    suiteid = Int()
 
1259
    exercise_id = Unicode(name="exerciseid")
 
1260
    description = Unicode()
 
1261
    seq_no = Int()
 
1262
    function = Unicode()
 
1263
    stdin = Unicode()
 
1264
    exercise = Reference(exercise_id, Exercise.id)
 
1265
    test_cases = ReferenceSet(suiteid, 'TestCase.suiteid', order_by="seq_no")
 
1266
    variables = ReferenceSet(suiteid, 'TestSuiteVar.suiteid', order_by='arg_no')
 
1267
 
 
1268
    def delete(self):
 
1269
        """Delete this suite, without asking questions."""
 
1270
        for variable in self.variables:
 
1271
            variable.delete()
 
1272
        for test_case in self.test_cases:
 
1273
            test_case.delete()
 
1274
        Store.of(self).remove(self)
 
1275
 
 
1276
class TestCase(Storm):
 
1277
    """A container for actual tests (see TestCasePart), inside a test suite.
 
1278
 
 
1279
    It is the lowest level shown to students on their pass/fail status."""
 
1280
 
 
1281
    __storm_table__ = "test_case"
 
1282
    __storm_primary__ = "testid", "suiteid"
 
1283
 
 
1284
    testid = Int()
 
1285
    suiteid = Int()
 
1286
    suite = Reference(suiteid, "TestSuite.suiteid")
 
1287
    passmsg = Unicode()
 
1288
    failmsg = Unicode()
 
1289
    test_default = Unicode() # Currently unused - only used for file matching.
 
1290
    seq_no = Int()
 
1291
 
 
1292
    parts = ReferenceSet(testid, "TestCasePart.testid")
 
1293
 
 
1294
    __init__ = _kwarg_init
 
1295
 
 
1296
    def delete(self):
 
1297
        for part in self.parts:
 
1298
            part.delete()
 
1299
        Store.of(self).remove(self)
 
1300
 
 
1301
class TestSuiteVar(Storm):
 
1302
    """A variable used by an exercise test suite.
 
1303
 
 
1304
    This may represent a function argument or a normal variable.
 
1305
    """
 
1306
 
 
1307
    __storm_table__ = "suite_variable"
 
1308
    __storm_primary__ = "varid"
 
1309
 
 
1310
    varid = Int()
 
1311
    suiteid = Int()
 
1312
    var_name = Unicode()
 
1313
    var_value = Unicode()
 
1314
    var_type = Unicode()
 
1315
    arg_no = Int()
 
1316
 
 
1317
    suite = Reference(suiteid, "TestSuite.suiteid")
 
1318
 
 
1319
    __init__ = _kwarg_init
 
1320
 
 
1321
    def delete(self):
 
1322
        Store.of(self).remove(self)
 
1323
 
 
1324
class TestCasePart(Storm):
 
1325
    """An actual piece of code to test an exercise solution."""
 
1326
 
 
1327
    __storm_table__ = "test_case_part"
 
1328
    __storm_primary__ = "partid"
 
1329
 
 
1330
    partid = Int()
 
1331
    testid = Int()
 
1332
 
 
1333
    part_type = Unicode()
 
1334
    test_type = Unicode()
 
1335
    data = Unicode()
 
1336
    filename = Unicode()
 
1337
 
 
1338
    test = Reference(testid, "TestCase.testid")
 
1339
 
 
1340
    __init__ = _kwarg_init
 
1341
 
 
1342
    def delete(self):
 
1343
        Store.of(self).remove(self)