← Back to branch summary

~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-21 04:20:44 UTC
  • Revision ID: matt.giuca@gmail.com-20100721042044-uopyzuiuji6vlsu7
Project page: Moved instructions under 'latest submissions' above the table, or it will be hard to see them under hundreds of submissions.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/database.py
17
17
 
18
18
# Author: Matt Giuca, Will Grant
19
19
 
20
 
"""
21
 
Database Classes and Utilities for Storm ORM
 
20
"""Database utilities and content classes.
22
21
 
23
22
This module provides all of the classes which map to database tables.
24
23
It also provides miscellaneous utility functions for database interaction.
25
24
"""
26
25
 
27
 
import md5
 
26
import hashlib
28
27
import datetime
 
28
import os
 
29
import urlparse
 
30
import urllib
29
31
 
30
32
from storm.locals import create_database, Store, Int, Unicode, DateTime, \
31
 
                         Reference
32
 
 
33
 
import ivle.conf
34
 
import ivle.caps
35
 
 
36
 
def get_conn_string():
37
 
    """
38
 
    Returns the Storm connection string, generated from the conf file.
39
 
    """
40
 
    return "postgres://%s:%s@%s:%d/%s" % (ivle.conf.db_user,
41
 
        ivle.conf.db_password, ivle.conf.db_host, ivle.conf.db_port,
42
 
        ivle.conf.db_dbname)
43
 
 
44
 
def get_store():
45
 
    """
46
 
    Open a database connection and transaction. Return a storm.store.Store
47
 
    instance connected to the configured IVLE database.
48
 
    """
49
 
    return Store(create_database(get_conn_string()))
50
 
 
51
 
class User(object):
52
 
    """
53
 
    Represents an IVLE user.
54
 
    """
 
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."""
55
87
    __storm_table__ = "login"
56
88
 
57
89
    id = Int(primary=True, name="loginid")
58
90
    login = Unicode()
59
91
    passhash = Unicode()
60
92
    state = Unicode()
61
 
    rolenm = Unicode()
 
93
    admin = Bool()
62
94
    unixid = Int()
63
95
    nick = Unicode()
64
96
    pass_exp = DateTime()
70
102
    studentid = Unicode()
71
103
    settings = Unicode()
72
104
 
73
 
    def _get_role(self):
74
 
        if self.rolenm is None:
75
 
            return None
76
 
        return ivle.caps.Role(self.rolenm)
77
 
    def _set_role(self, value):
78
 
        if not isinstance(value, ivle.caps.Role):
79
 
            raise TypeError("role must be an ivle.caps.Role")
80
 
        self.rolenm = unicode(value)
81
 
    role = property(_get_role, _set_role)
82
 
 
83
 
    def __init__(self, **kwargs):
84
 
        """
85
 
        Create a new User object. Supply any columns as a keyword argument.
86
 
        """
87
 
        for k,v in kwargs.items():
88
 
            if k.startswith('_') or not hasattr(self, k):
89
 
                raise TypeError("User got an unexpected keyword argument '%s'"
90
 
                    % k)
91
 
            setattr(self, k, v)
 
105
    __init__ = _kwarg_init
92
106
 
93
107
    def __repr__(self):
94
108
        return "<%s '%s'>" % (type(self).__name__, self.login)
104
118
            return None
105
119
        return self.hash_password(password) == self.passhash
106
120
 
107
 
    def hasCap(self, capability):
108
 
        """Given a capability (which is a Role object), returns True if this
109
 
        User has that capability, False otherwise.
110
 
        """
111
 
        return self.role.hasCap(capability)
 
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
112
130
 
113
131
    @property
114
132
    def password_expired(self):
120
138
        fieldval = self.acct_exp
121
139
        return fieldval is not None and datetime.datetime.now() > fieldval
122
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
 
123
224
    @staticmethod
124
225
    def hash_password(password):
125
 
        return md5.md5(password).hexdigest()
 
226
        """Hash a password with MD5."""
 
227
        return hashlib.md5(password).hexdigest()
126
228
 
127
229
    @classmethod
128
230
    def get_by_login(cls, store, login):
129
 
        """
130
 
        Get the User from the db associated with a given store and
131
 
        login.
132
 
        """
 
231
        """Find a user in a store by login name."""
133
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):
 
614
        return (self in principal.get_projects() and
 
615
                not self.has_deadline_passed(user))
 
616
 
 
617
    def submit(self, principal, path, revision, who):
 
618
        """Submit a Subversion path and revision to a project.
 
619
 
 
620
        @param principal: The owner of the Subversion repository, and the
 
621
                          entity on behalf of whom the submission is being made
 
622
        @param path: A path within that repository to submit.
 
623
        @param revision: The revision of that path to submit.
 
624
        @param who: The user who is actually making the submission.
 
625
        """
 
626
 
 
627
        if not self.can_submit(principal, who):
 
628
            raise DeadlinePassed()
 
629
 
 
630
        a = Assessed.get(Store.of(self), principal, self)
 
631
        ps = ProjectSubmission()
 
632
        # Raise SubmissionError if the path is illegal
 
633
        ps.path = ProjectSubmission.test_and_normalise_path(path)
 
634
        ps.revision = revision
 
635
        ps.date_submitted = datetime.datetime.now()
 
636
        ps.assessed = a
 
637
        ps.submitter = who
 
638
 
 
639
        return ps
 
640
 
 
641
    def get_permissions(self, user, config):
 
642
        return self.project_set.offering.get_permissions(user, config)
 
643
 
 
644
    @property
 
645
    def latest_submissions(self):
 
646
        """Return the latest submission for each Assessed."""
 
647
        return Store.of(self).find(ProjectSubmission,
 
648
            Assessed.project_id == self.id,
 
649
            ProjectSubmission.assessed_id == Assessed.id,
 
650
            ProjectSubmission.date_submitted == Select(
 
651
                    Max(ProjectSubmission.date_submitted),
 
652
                    ProjectSubmission.assessed_id == Assessed.id,
 
653
                    tables=ProjectSubmission
 
654
            )
 
655
        )
 
656
 
 
657
    def has_deadline_passed(self, user):
 
658
        """Check whether the deadline has passed."""
 
659
        # XXX: Need to respect extensions.
 
660
        return self.deadline < datetime.datetime.now()
 
661
 
 
662
    def get_submissions_for_principal(self, principal):
 
663
        """Fetch a ResultSet of all submissions by a particular principal."""
 
664
        assessed = Assessed.get(Store.of(self), principal, self)
 
665
        if assessed is None:
 
666
            return
 
667
        return assessed.submissions
 
668
 
 
669
    @property
 
670
    def can_delete(self):
 
671
        """Can only delete if there are no submissions."""
 
672
        return self.submissions.count() == 0
 
673
 
 
674
    def delete(self):
 
675
        """Delete the project. Fails if can_delete is False."""
 
676
        if not self.can_delete:
 
677
            raise IntegrityError()
 
678
        for assessed in self.assesseds:
 
679
            assessed.delete()
 
680
        Store.of(self).remove(self)
 
681
 
 
682
class ProjectGroup(Storm):
 
683
    """A group of students working together on a project."""
 
684
 
 
685
    __storm_table__ = "project_group"
 
686
 
 
687
    id = Int(name="groupid", primary=True)
 
688
    name = Unicode(name="groupnm")
 
689
    project_set_id = Int(name="projectsetid")
 
690
    project_set = Reference(project_set_id, ProjectSet.id)
 
691
    nick = Unicode()
 
692
    created_by_id = Int(name="createdby")
 
693
    created_by = Reference(created_by_id, User.id)
 
694
    epoch = DateTime()
 
695
 
 
696
    members = ReferenceSet(id,
 
697
                           "ProjectGroupMembership.project_group_id",
 
698
                           "ProjectGroupMembership.user_id",
 
699
                           "User.id")
 
700
 
 
701
    __init__ = _kwarg_init
 
702
 
 
703
    def __repr__(self):
 
704
        return "<%s %s in %r>" % (type(self).__name__, self.name,
 
705
                                  self.project_set.offering)
 
706
 
 
707
    @property
 
708
    def display_name(self):
 
709
        """Returns the "nice name" of the user or group."""
 
710
        return self.nick
 
711
 
 
712
    @property
 
713
    def short_name(self):
 
714
        """Returns the database "identifier" name of the user or group."""
 
715
        return self.name
 
716
 
 
717
    def get_projects(self, offering=None, active_only=True):
 
718
        '''Find projects that the group can submit.
 
719
 
 
720
        This will include projects in the project set which owns this group,
 
721
        unless the project set disallows groups (in which case none will be
 
722
        returned).
 
723
 
 
724
        @param active_only: Whether to only search active offerings.
 
725
        @param offering: An optional offering to restrict the search to.
 
726
        '''
 
727
        return Store.of(self).find(Project,
 
728
            Project.project_set_id == ProjectSet.id,
 
729
            ProjectSet.id == self.project_set.id,
 
730
            ProjectSet.max_students_per_group != None,
 
731
            ProjectSet.offering_id == Offering.id,
 
732
            (offering is None) or (Offering.id == offering.id),
 
733
            Semester.id == Offering.semester_id,
 
734
            (not active_only) or (Semester.state == u'current'))
 
735
 
 
736
    def get_svn_url(self, config):
 
737
        """Get the subversion repository URL for this user or group."""
 
738
        url = config['urls']['svn_addr']
 
739
        path = 'groups/%s_%s_%s_%s' % (
 
740
                self.project_set.offering.subject.short_name,
 
741
                self.project_set.offering.semester.year,
 
742
                self.project_set.offering.semester.semester,
 
743
                self.name
 
744
                )
 
745
        return urlparse.urljoin(url, path)
 
746
 
 
747
    def get_permissions(self, user, config):
 
748
        if user.admin or user in self.members:
 
749
            return set(['submit_project'])
 
750
        else:
 
751
            return set()
 
752
 
 
753
class ProjectGroupMembership(Storm):
 
754
    """A student's membership in a project group."""
 
755
 
 
756
    __storm_table__ = "group_member"
 
757
    __storm_primary__ = "user_id", "project_group_id"
 
758
 
 
759
    user_id = Int(name="loginid")
 
760
    user = Reference(user_id, User.id)
 
761
    project_group_id = Int(name="groupid")
 
762
    project_group = Reference(project_group_id, ProjectGroup.id)
 
763
 
 
764
    __init__ = _kwarg_init
 
765
 
 
766
    def __repr__(self):
 
767
        return "<%s %r in %r>" % (type(self).__name__, self.user,
 
768
                                  self.project_group)
 
769
 
 
770
class Assessed(Storm):
 
771
    """A composite of a user or group combined with a project.
 
772
 
 
773
    Each project submission and extension refers to an Assessed. It is the
 
774
    sole specifier of the repository and project.
 
775
    """
 
776
 
 
777
    __storm_table__ = "assessed"
 
778
 
 
779
    id = Int(name="assessedid", primary=True)
 
780
    user_id = Int(name="loginid")
 
781
    user = Reference(user_id, User.id)
 
782
    project_group_id = Int(name="groupid")
 
783
    project_group = Reference(project_group_id, ProjectGroup.id)
 
784
 
 
785
    project_id = Int(name="projectid")
 
786
    project = Reference(project_id, Project.id)
 
787
 
 
788
    extensions = ReferenceSet(id, 'ProjectExtension.assessed_id')
 
789
    submissions = ReferenceSet(
 
790
        id, 'ProjectSubmission.assessed_id', order_by='date_submitted')
 
791
 
 
792
    def __repr__(self):
 
793
        return "<%s %r in %r>" % (type(self).__name__,
 
794
            self.user or self.project_group, self.project)
 
795
 
 
796
    @property
 
797
    def is_group(self):
 
798
        """True if the Assessed is a group, False if it is a user."""
 
799
        return self.project_group is not None
 
800
 
 
801
    @property
 
802
    def principal(self):
 
803
        return self.project_group or self.user
 
804
 
 
805
    @property
 
806
    def checkout_location(self):
 
807
        """Returns the location of the Subversion workspace for this piece of
 
808
        assessment, relative to each group member's home directory."""
 
809
        subjectname = self.project.project_set.offering.subject.short_name
 
810
        if self.is_group:
 
811
            checkout_dir_name = self.principal.short_name
 
812
        else:
 
813
            checkout_dir_name = "mywork"
 
814
        return subjectname + "/" + checkout_dir_name
 
815
 
 
816
    @classmethod
 
817
    def get(cls, store, principal, project):
 
818
        """Find or create an Assessed for the given user or group and project.
 
819
 
 
820
        @param principal: The user or group.
 
821
        @param project: The project.
 
822
        """
 
823
        t = type(principal)
 
824
        if t not in (User, ProjectGroup):
 
825
            raise AssertionError('principal must be User or ProjectGroup')
 
826
 
 
827
        a = store.find(cls,
 
828
            (t is User) or (cls.project_group_id == principal.id),
 
829
            (t is ProjectGroup) or (cls.user_id == principal.id),
 
830
            cls.project_id == project.id).one()
 
831
 
 
832
        if a is None:
 
833
            a = cls()
 
834
            if t is User:
 
835
                a.user = principal
 
836
            else:
 
837
                a.project_group = principal
 
838
            a.project = project
 
839
            store.add(a)
 
840
 
 
841
        return a
 
842
 
 
843
    def delete(self):
 
844
        """Delete the assessed. Fails if there are any submissions. Deletes
 
845
        extensions."""
 
846
        if self.submissions.count() > 0:
 
847
            raise IntegrityError()
 
848
        for extension in self.extensions:
 
849
            extension.delete()
 
850
        Store.of(self).remove(self)
 
851
 
 
852
class ProjectExtension(Storm):
 
853
    """An extension granted to a user or group on a particular project.
 
854
 
 
855
    The user or group and project are specified by the Assessed.
 
856
    """
 
857
 
 
858
    __storm_table__ = "project_extension"
 
859
 
 
860
    id = Int(name="extensionid", primary=True)
 
861
    assessed_id = Int(name="assessedid")
 
862
    assessed = Reference(assessed_id, Assessed.id)
 
863
    deadline = DateTime()
 
864
    approver_id = Int(name="approver")
 
865
    approver = Reference(approver_id, User.id)
 
866
    notes = Unicode()
 
867
 
 
868
    def delete(self):
 
869
        """Delete the extension."""
 
870
        Store.of(self).remove(self)
 
871
 
 
872
class SubmissionError(Exception):
 
873
    """Denotes a validation error during submission."""
 
874
    pass
 
875
 
 
876
class ProjectSubmission(Storm):
 
877
    """A submission from a user or group repository to a particular project.
 
878
 
 
879
    The content of a submission is a single path and revision inside a
 
880
    repository. The repository is that owned by the submission's user and
 
881
    group, while the path and revision are explicit.
 
882
 
 
883
    The user or group and project are specified by the Assessed.
 
884
    """
 
885
 
 
886
    __storm_table__ = "project_submission"
 
887
 
 
888
    id = Int(name="submissionid", primary=True)
 
889
    assessed_id = Int(name="assessedid")
 
890
    assessed = Reference(assessed_id, Assessed.id)
 
891
    path = Unicode()
 
892
    revision = Int()
 
893
    submitter_id = Int(name="submitter")
 
894
    submitter = Reference(submitter_id, User.id)
 
895
    date_submitted = DateTime()
 
896
 
 
897
    def get_verify_url(self, user):
 
898
        """Get the URL for verifying this submission, within the account of
 
899
        the given user."""
 
900
        # If this is a solo project, then self.path will be prefixed with the
 
901
        # subject name. Remove the first path segment.
 
902
        submitpath = self.path[1:] if self.path[:1] == '/' else self.path
 
903
        if not self.assessed.is_group:
 
904
            if '/' in submitpath:
 
905
                submitpath = submitpath.split('/', 1)[1]
 
906
            else:
 
907
                submitpath = ''
 
908
        return "/files/%s/%s/%s?r=%d" % (user.login,
 
909
            self.assessed.checkout_location, submitpath, self.revision)
 
910
 
 
911
    def get_svn_url(self, config):
 
912
        """Get subversion URL for this submission"""
 
913
        princ = self.assessed.principal
 
914
        base = princ.get_svn_url(config)
 
915
        if self.path.startswith(os.sep):
 
916
            return os.path.join(base,
 
917
                    urllib.quote(self.path[1:].encode('utf-8')))
 
918
        else:
 
919
            return os.path.join(base, urllib.quote(self.path.encode('utf-8')))
 
920
 
 
921
    def get_svn_export_command(self, req):
 
922
        """Returns a Unix shell command to export a submission"""
 
923
        svn_url = self.get_svn_url(req.config)
 
924
        username = (req.user.login if req.user.login.isalnum() else
 
925
                "'%s'"%req.user.login)
 
926
        export_dir = self.assessed.principal.short_name
 
927
        return "svn export --username %s -r%d '%s' %s"%(req.user.login,
 
928
                self.revision, svn_url, export_dir)
 
929
 
 
930
    @staticmethod
 
931
    def test_and_normalise_path(path):
 
932
        """Test that path is valid, and normalise it. This prevents possible
 
933
        injections using malicious paths.
 
934
        Returns the updated path, if successful.
 
935
        Raises SubmissionError if invalid.
 
936
        """
 
937
        # Ensure the path is absolute to prevent being tacked onto working
 
938
        # directories.
 
939
        # Prevent '\n' because it will break all sorts of things.
 
940
        # Prevent '[' and ']' because they can be used to inject into the
 
941
        # svn.conf.
 
942
        # Normalise to avoid resulting in ".." path segments.
 
943
        if not os.path.isabs(path):
 
944
            raise SubmissionError("Path is not absolute")
 
945
        if any(c in path for c in "\n[]"):
 
946
            raise SubmissionError("Path must not contain '\\n', '[' or ']'")
 
947
        return os.path.normpath(path)
 
948
 
 
949
# WORKSHEETS AND EXERCISES #
 
950
 
 
951
class Exercise(Storm):
 
952
    """An exercise for students to complete in a worksheet.
 
953
 
 
954
    An exercise may be present in any number of worksheets.
 
955
    """
 
956
 
 
957
    __storm_table__ = "exercise"
 
958
    id = Unicode(primary=True, name="identifier")
 
959
    name = Unicode()
 
960
    description = Unicode()
 
961
    _description_xhtml_cache = Unicode(name='description_xhtml_cache')
 
962
    partial = Unicode()
 
963
    solution = Unicode()
 
964
    include = Unicode()
 
965
    num_rows = Int()
 
966
 
 
967
    worksheet_exercises =  ReferenceSet(id,
 
968
        'WorksheetExercise.exercise_id')
 
969
 
 
970
    worksheets = ReferenceSet(id,
 
971
        'WorksheetExercise.exercise_id',
 
972
        'WorksheetExercise.worksheet_id',
 
973
        'Worksheet.id'
 
974
    )
 
975
 
 
976
    test_suites = ReferenceSet(id, 
 
977
        'TestSuite.exercise_id',
 
978
        order_by='seq_no')
 
979
 
 
980
    __init__ = _kwarg_init
 
981
 
 
982
    def __repr__(self):
 
983
        return "<%s %s>" % (type(self).__name__, self.name)
 
984
 
 
985
    def get_permissions(self, user, config):
 
986
        return self.global_permissions(user, config)
 
987
 
 
988
    @staticmethod
 
989
    def global_permissions(user, config):
 
990
        """Gets the set of permissions this user has over *all* exercises.
 
991
        This is used to determine who may view the exercises list, and create
 
992
        new exercises."""
 
993
        perms = set()
 
994
        roles = set()
 
995
        if user is not None:
 
996
            if user.admin:
 
997
                perms.add('edit')
 
998
                perms.add('view')
 
999
            elif u'lecturer' in set((e.role for e in user.active_enrolments)):
 
1000
                perms.add('edit')
 
1001
                perms.add('view')
 
1002
            elif (config['policy']['tutors_can_edit_worksheets']
 
1003
            and u'tutor' in set((e.role for e in user.active_enrolments))):
 
1004
                # Site-specific policy on the role of tutors
 
1005
                perms.add('edit')
 
1006
                perms.add('view')
 
1007
 
 
1008
        return perms
 
1009
 
 
1010
    def _cache_description_xhtml(self, invalidate=False):
 
1011
        # Don't regenerate an existing cache unless forced.
 
1012
        if self._description_xhtml_cache is not None and not invalidate:
 
1013
            return
 
1014
 
 
1015
        if self.description:
 
1016
            self._description_xhtml_cache = rst(self.description)
 
1017
        else:
 
1018
            self._description_xhtml_cache = None
 
1019
 
 
1020
    @property
 
1021
    def description_xhtml(self):
 
1022
        """The XHTML exercise description, converted from reStructuredText."""
 
1023
        self._cache_description_xhtml()
 
1024
        return self._description_xhtml_cache
 
1025
 
 
1026
    def set_description(self, description):
 
1027
        self.description = description
 
1028
        self._cache_description_xhtml(invalidate=True)
 
1029
 
 
1030
    def delete(self):
 
1031
        """Deletes the exercise, providing it has no associated worksheets."""
 
1032
        if (self.worksheet_exercises.count() > 0):
 
1033
            raise IntegrityError()
 
1034
        for suite in self.test_suites:
 
1035
            suite.delete()
 
1036
        Store.of(self).remove(self)
 
1037
 
 
1038
class Worksheet(Storm):
 
1039
    """A worksheet with exercises for students to complete.
 
1040
 
 
1041
    Worksheets are owned by offerings.
 
1042
    """
 
1043
 
 
1044
    __storm_table__ = "worksheet"
 
1045
 
 
1046
    id = Int(primary=True, name="worksheetid")
 
1047
    offering_id = Int(name="offeringid")
 
1048
    identifier = Unicode()
 
1049
    name = Unicode()
 
1050
    assessable = Bool()
 
1051
    published = Bool()
 
1052
    data = Unicode()
 
1053
    _data_xhtml_cache = Unicode(name='data_xhtml_cache')
 
1054
    seq_no = Int()
 
1055
    format = Unicode()
 
1056
 
 
1057
    attempts = ReferenceSet(id, "ExerciseAttempt.worksheetid")
 
1058
    offering = Reference(offering_id, 'Offering.id')
 
1059
 
 
1060
    all_worksheet_exercises = ReferenceSet(id,
 
1061
        'WorksheetExercise.worksheet_id')
 
1062
 
 
1063
    # Use worksheet_exercises to get access to the *active* WorksheetExercise
 
1064
    # objects binding worksheets to exercises. This is required to access the
 
1065
    # "optional" field.
 
1066
 
 
1067
    @property
 
1068
    def worksheet_exercises(self):
 
1069
        return self.all_worksheet_exercises.find(active=True)
 
1070
 
 
1071
    __init__ = _kwarg_init
 
1072
 
 
1073
    def __repr__(self):
 
1074
        return "<%s %s>" % (type(self).__name__, self.name)
 
1075
 
 
1076
    def remove_all_exercises(self):
 
1077
        """Remove all exercises from this worksheet.
 
1078
 
 
1079
        This does not delete the exercises themselves. It just removes them
 
1080
        from the worksheet.
 
1081
        """
 
1082
        store = Store.of(self)
 
1083
        for ws_ex in self.all_worksheet_exercises:
 
1084
            if ws_ex.saves.count() > 0 or ws_ex.attempts.count() > 0:
 
1085
                raise IntegrityError()
 
1086
        store.find(WorksheetExercise,
 
1087
            WorksheetExercise.worksheet == self).remove()
 
1088
 
 
1089
    def get_permissions(self, user, config):
 
1090
        offering_perms = self.offering.get_permissions(user, config)
 
1091
 
 
1092
        perms = set()
 
1093
 
 
1094
        # Anybody who can view an offering can view a published
 
1095
        # worksheet.
 
1096
        if 'view' in offering_perms and self.published:
 
1097
            perms.add('view')
 
1098
 
 
1099
        # Any worksheet editors can both view and edit.
 
1100
        if 'edit_worksheets' in offering_perms:
 
1101
            perms.add('view')
 
1102
            perms.add('edit')
 
1103
 
 
1104
        return perms
 
1105
 
 
1106
    def _cache_data_xhtml(self, invalidate=False):
 
1107
        # Don't regenerate an existing cache unless forced.
 
1108
        if self._data_xhtml_cache is not None and not invalidate:
 
1109
            return
 
1110
 
 
1111
        if self.format == u'rst':
 
1112
            self._data_xhtml_cache = rst(self.data)
 
1113
        else:
 
1114
            self._data_xhtml_cache = None
 
1115
 
 
1116
    @property
 
1117
    def data_xhtml(self):
 
1118
        """The XHTML of this worksheet, converted from rST if required."""
 
1119
        # Update the rST -> XHTML cache, if required.
 
1120
        self._cache_data_xhtml()
 
1121
 
 
1122
        if self.format == u'rst':
 
1123
            return self._data_xhtml_cache
 
1124
        else:
 
1125
            return self.data
 
1126
 
 
1127
    def set_data(self, data):
 
1128
        self.data = data
 
1129
        self._cache_data_xhtml(invalidate=True)
 
1130
 
 
1131
    def delete(self):
 
1132
        """Deletes the worksheet, provided it has no attempts on any exercises.
 
1133
 
 
1134
        Returns True if delete succeeded, or False if this worksheet has
 
1135
        attempts attached."""
 
1136
        for ws_ex in self.all_worksheet_exercises:
 
1137
            if ws_ex.saves.count() > 0 or ws_ex.attempts.count() > 0:
 
1138
                raise IntegrityError()
 
1139
 
 
1140
        self.remove_all_exercises()
 
1141
        Store.of(self).remove(self)
 
1142
 
 
1143
class WorksheetExercise(Storm):
 
1144
    """A link between a worksheet and one of its exercises.
 
1145
 
 
1146
    These may be marked optional, in which case the exercise does not count
 
1147
    for marking purposes. The sequence number is used to order the worksheet
 
1148
    ToC.
 
1149
    """
 
1150
 
 
1151
    __storm_table__ = "worksheet_exercise"
 
1152
 
 
1153
    id = Int(primary=True, name="ws_ex_id")
 
1154
 
 
1155
    worksheet_id = Int(name="worksheetid")
 
1156
    worksheet = Reference(worksheet_id, Worksheet.id)
 
1157
    exercise_id = Unicode(name="exerciseid")
 
1158
    exercise = Reference(exercise_id, Exercise.id)
 
1159
    optional = Bool()
 
1160
    active = Bool()
 
1161
    seq_no = Int()
 
1162
 
 
1163
    saves = ReferenceSet(id, "ExerciseSave.ws_ex_id")
 
1164
    attempts = ReferenceSet(id, "ExerciseAttempt.ws_ex_id")
 
1165
 
 
1166
    __init__ = _kwarg_init
 
1167
 
 
1168
    def __repr__(self):
 
1169
        return "<%s %s in %s>" % (type(self).__name__, self.exercise.name,
 
1170
                                  self.worksheet.identifier)
 
1171
 
 
1172
    def get_permissions(self, user, config):
 
1173
        return self.worksheet.get_permissions(user, config)
 
1174
 
 
1175
 
 
1176
class ExerciseSave(Storm):
 
1177
    """A potential exercise solution submitted by a user for storage.
 
1178
 
 
1179
    This is not an actual tested attempt at an exercise, it's just a save of
 
1180
    the editing session.
 
1181
    """
 
1182
 
 
1183
    __storm_table__ = "exercise_save"
 
1184
    __storm_primary__ = "ws_ex_id", "user_id"
 
1185
 
 
1186
    ws_ex_id = Int(name="ws_ex_id")
 
1187
    worksheet_exercise = Reference(ws_ex_id, "WorksheetExercise.id")
 
1188
 
 
1189
    user_id = Int(name="loginid")
 
1190
    user = Reference(user_id, User.id)
 
1191
    date = DateTime()
 
1192
    text = Unicode()
 
1193
 
 
1194
    __init__ = _kwarg_init
 
1195
 
 
1196
    def __repr__(self):
 
1197
        return "<%s %s by %s at %s>" % (type(self).__name__,
 
1198
            self.worksheet_exercise.exercise.name, self.user.login,
 
1199
            self.date.strftime("%c"))
 
1200
 
 
1201
class ExerciseAttempt(ExerciseSave):
 
1202
    """An attempt at solving an exercise.
 
1203
 
 
1204
    This is a special case of ExerciseSave, used when the user submits a
 
1205
    candidate solution. Like an ExerciseSave, it constitutes exercise solution
 
1206
    data.
 
1207
 
 
1208
    In addition, it contains information about the result of the submission:
 
1209
 
 
1210
     - complete - True if this submission was successful, rendering this
 
1211
                  exercise complete for this user in this worksheet.
 
1212
     - active   - True if this submission is "active" (usually true).
 
1213
                  Submissions may be de-activated by privileged users for
 
1214
                  special reasons, and then they won't count (either as a
 
1215
                  penalty or success), but will still be stored.
 
1216
    """
 
1217
 
 
1218
    __storm_table__ = "exercise_attempt"
 
1219
    __storm_primary__ = "ws_ex_id", "user_id", "date"
 
1220
 
 
1221
    # The "text" field is the same but has a different name in the DB table
 
1222
    # for some reason.
 
1223
    text = Unicode(name="attempt")
 
1224
    complete = Bool()
 
1225
    active = Bool()
 
1226
 
 
1227
    def get_permissions(self, user, config):
 
1228
        return set(['view']) if user is self.user else set()
 
1229
 
 
1230
class TestSuite(Storm):
 
1231
    """A container to group an exercise's test cases.
 
1232
 
 
1233
    The test suite contains some information on how to test. The function to
 
1234
    test, variables to set and stdin data are stored here.
 
1235
    """
 
1236
 
 
1237
    __storm_table__ = "test_suite"
 
1238
    __storm_primary__ = "exercise_id", "suiteid"
 
1239
 
 
1240
    suiteid = Int()
 
1241
    exercise_id = Unicode(name="exerciseid")
 
1242
    description = Unicode()
 
1243
    seq_no = Int()
 
1244
    function = Unicode()
 
1245
    stdin = Unicode()
 
1246
    exercise = Reference(exercise_id, Exercise.id)
 
1247
    test_cases = ReferenceSet(suiteid, 'TestCase.suiteid', order_by="seq_no")
 
1248
    variables = ReferenceSet(suiteid, 'TestSuiteVar.suiteid', order_by='arg_no')
 
1249
 
 
1250
    def delete(self):
 
1251
        """Delete this suite, without asking questions."""
 
1252
        for variable in self.variables:
 
1253
            variable.delete()
 
1254
        for test_case in self.test_cases:
 
1255
            test_case.delete()
 
1256
        Store.of(self).remove(self)
 
1257
 
 
1258
class TestCase(Storm):
 
1259
    """A container for actual tests (see TestCasePart), inside a test suite.
 
1260
 
 
1261
    It is the lowest level shown to students on their pass/fail status."""
 
1262
 
 
1263
    __storm_table__ = "test_case"
 
1264
    __storm_primary__ = "testid", "suiteid"
 
1265
 
 
1266
    testid = Int()
 
1267
    suiteid = Int()
 
1268
    suite = Reference(suiteid, "TestSuite.suiteid")
 
1269
    passmsg = Unicode()
 
1270
    failmsg = Unicode()
 
1271
    test_default = Unicode() # Currently unused - only used for file matching.
 
1272
    seq_no = Int()
 
1273
 
 
1274
    parts = ReferenceSet(testid, "TestCasePart.testid")
 
1275
 
 
1276
    __init__ = _kwarg_init
 
1277
 
 
1278
    def delete(self):
 
1279
        for part in self.parts:
 
1280
            part.delete()
 
1281
        Store.of(self).remove(self)
 
1282
 
 
1283
class TestSuiteVar(Storm):
 
1284
    """A variable used by an exercise test suite.
 
1285
 
 
1286
    This may represent a function argument or a normal variable.
 
1287
    """
 
1288
 
 
1289
    __storm_table__ = "suite_variable"
 
1290
    __storm_primary__ = "varid"
 
1291
 
 
1292
    varid = Int()
 
1293
    suiteid = Int()
 
1294
    var_name = Unicode()
 
1295
    var_value = Unicode()
 
1296
    var_type = Unicode()
 
1297
    arg_no = Int()
 
1298
 
 
1299
    suite = Reference(suiteid, "TestSuite.suiteid")
 
1300
 
 
1301
    __init__ = _kwarg_init
 
1302
 
 
1303
    def delete(self):
 
1304
        Store.of(self).remove(self)
 
1305
 
 
1306
class TestCasePart(Storm):
 
1307
    """An actual piece of code to test an exercise solution."""
 
1308
 
 
1309
    __storm_table__ = "test_case_part"
 
1310
    __storm_primary__ = "partid"
 
1311
 
 
1312
    partid = Int()
 
1313
    testid = Int()
 
1314
 
 
1315
    part_type = Unicode()
 
1316
    test_type = Unicode()
 
1317
    data = Unicode()
 
1318
    filename = Unicode()
 
1319
 
 
1320
    test = Reference(testid, "TestCase.testid")
 
1321
 
 
1322
    __init__ = _kwarg_init
 
1323
 
 
1324
    def delete(self):
 
1325
        Store.of(self).remove(self)