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

« back to all changes in this revision

Viewing changes to ivle/database.py

Fixed a broken link when adding a new project.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
29
28
 
30
29
from storm.locals import create_database, Store, Int, Unicode, DateTime, \
31
30
                         Reference, ReferenceSet, Bool, Storm, Desc
 
31
from storm.exceptions import NotOneError, IntegrityError
32
32
 
33
 
import ivle.conf
34
 
import ivle.caps
 
33
from ivle.worksheet.rst import rst
35
34
 
36
35
__all__ = ['get_store',
37
36
            'User',
38
37
            'Subject', 'Semester', 'Offering', 'Enrolment',
39
38
            'ProjectSet', 'Project', 'ProjectGroup', 'ProjectGroupMembership',
 
39
            'Assessed', 'ProjectSubmission', 'ProjectExtension',
40
40
            'Exercise', 'Worksheet', 'WorksheetExercise',
41
41
            'ExerciseSave', 'ExerciseAttempt',
42
 
            'AlreadyEnrolledError', 'TestCase', 'TestSuite'
 
42
            'TestCase', 'TestSuite', 'TestSuiteVar'
43
43
        ]
44
44
 
45
45
def _kwarg_init(self, **kwargs):
49
49
                % (self.__class__.__name__, k))
50
50
        setattr(self, k, v)
51
51
 
52
 
def get_conn_string():
53
 
    """
54
 
    Returns the Storm connection string, generated from the conf file.
55
 
    """
56
 
    return "postgres://%s:%s@%s:%d/%s" % (ivle.conf.db_user,
57
 
        ivle.conf.db_password, ivle.conf.db_host, ivle.conf.db_port,
58
 
        ivle.conf.db_dbname)
59
 
 
60
 
def get_store():
61
 
    """
62
 
    Open a database connection and transaction. Return a storm.store.Store
63
 
    instance connected to the configured IVLE database.
64
 
    """
65
 
    return Store(create_database(get_conn_string()))
 
52
def get_conn_string(config):
 
53
    """Create a Storm connection string to the IVLE database
 
54
 
 
55
    @param config: The IVLE configuration.
 
56
    """
 
57
 
 
58
    clusterstr = ''
 
59
    if config['database']['username']:
 
60
        clusterstr += config['database']['username']
 
61
        if config['database']['password']:
 
62
            clusterstr += ':' + config['database']['password']
 
63
        clusterstr += '@'
 
64
 
 
65
    host = config['database']['host'] or 'localhost'
 
66
    port = config['database']['port'] or 5432
 
67
 
 
68
    clusterstr += '%s:%d' % (host, port)
 
69
 
 
70
    return "postgres://%s/%s" % (clusterstr, config['database']['name'])
 
71
 
 
72
def get_store(config):
 
73
    """Create a Storm store connected to the IVLE database.
 
74
 
 
75
    @param config: The IVLE configuration.
 
76
    """
 
77
    return Store(create_database(get_conn_string(config)))
66
78
 
67
79
# USERS #
68
80
 
69
81
class User(Storm):
70
 
    """
71
 
    Represents an IVLE user.
72
 
    """
 
82
    """An IVLE user account."""
73
83
    __storm_table__ = "login"
74
84
 
75
85
    id = Int(primary=True, name="loginid")
76
86
    login = Unicode()
77
87
    passhash = Unicode()
78
88
    state = Unicode()
79
 
    rolenm = Unicode()
 
89
    admin = Bool()
80
90
    unixid = Int()
81
91
    nick = Unicode()
82
92
    pass_exp = DateTime()
88
98
    studentid = Unicode()
89
99
    settings = Unicode()
90
100
 
91
 
    def _get_role(self):
92
 
        if self.rolenm is None:
93
 
            return None
94
 
        return ivle.caps.Role(self.rolenm)
95
 
    def _set_role(self, value):
96
 
        if not isinstance(value, ivle.caps.Role):
97
 
            raise TypeError("role must be an ivle.caps.Role")
98
 
        self.rolenm = unicode(value)
99
 
    role = property(_get_role, _set_role)
100
 
 
101
101
    __init__ = _kwarg_init
102
102
 
103
103
    def __repr__(self):
114
114
            return None
115
115
        return self.hash_password(password) == self.passhash
116
116
 
117
 
    def hasCap(self, capability):
118
 
        """Given a capability (which is a Role object), returns True if this
119
 
        User has that capability, False otherwise.
120
 
        """
121
 
        return self.role.hasCap(capability)
 
117
    @property
 
118
    def display_name(self):
 
119
        return self.fullname
122
120
 
123
121
    @property
124
122
    def password_expired(self):
163
161
 
164
162
    # TODO: Invitations should be listed too?
165
163
    def get_groups(self, offering=None):
 
164
        """Get groups of which this user is a member.
 
165
 
 
166
        @param offering: An optional offering to restrict the search to.
 
167
        """
166
168
        preds = [
167
169
            ProjectGroupMembership.user_id == self.id,
168
170
            ProjectGroup.id == ProjectGroupMembership.project_group_id,
188
190
        '''A sanely ordered list of all of the user's enrolments.'''
189
191
        return self._get_enrolments(False) 
190
192
 
 
193
    def get_projects(self, offering=None, active_only=True):
 
194
        """Find projects that the user can submit.
 
195
 
 
196
        This will include projects for offerings in which the user is
 
197
        enrolled, as long as the project is not in a project set which has
 
198
        groups (ie. if maximum number of group members is 0).
 
199
 
 
200
        @param active_only: Whether to only search active offerings.
 
201
        @param offering: An optional offering to restrict the search to.
 
202
        """
 
203
        return Store.of(self).find(Project,
 
204
            Project.project_set_id == ProjectSet.id,
 
205
            ProjectSet.max_students_per_group == None,
 
206
            ProjectSet.offering_id == Offering.id,
 
207
            (offering is None) or (Offering.id == offering.id),
 
208
            Semester.id == Offering.semester_id,
 
209
            (not active_only) or (Semester.state == u'current'),
 
210
            Enrolment.offering_id == Offering.id,
 
211
            Enrolment.user_id == self.id)
 
212
 
191
213
    @staticmethod
192
214
    def hash_password(password):
193
 
        return md5.md5(password).hexdigest()
 
215
        """Hash a password with MD5."""
 
216
        return hashlib.md5(password).hexdigest()
194
217
 
195
218
    @classmethod
196
219
    def get_by_login(cls, store, login):
197
 
        """
198
 
        Get the User from the db associated with a given store and
199
 
        login.
200
 
        """
 
220
        """Find a user in a store by login name."""
201
221
        return store.find(cls, cls.login == unicode(login)).one()
202
222
 
203
223
    def get_permissions(self, user):
204
 
        if user and user.rolenm == 'admin' or user is self:
205
 
            return set(['view', 'edit'])
 
224
        """Determine privileges held by a user over this object.
 
225
 
 
226
        If the user requesting privileges is this user or an admin,
 
227
        they may do everything. Otherwise they may do nothing.
 
228
        """
 
229
        if user and user.admin or user is self:
 
230
            return set(['view', 'edit', 'submit_project'])
206
231
        else:
207
232
            return set()
208
233
 
209
234
# SUBJECTS AND ENROLMENTS #
210
235
 
211
236
class Subject(Storm):
 
237
    """A subject (or course) which is run in some semesters."""
 
238
 
212
239
    __storm_table__ = "subject"
213
240
 
214
241
    id = Int(primary=True, name="subjectid")
225
252
        return "<%s '%s'>" % (type(self).__name__, self.short_name)
226
253
 
227
254
    def get_permissions(self, user):
 
255
        """Determine privileges held by a user over this object.
 
256
 
 
257
        If the user requesting privileges is an admin, they may edit.
 
258
        Otherwise they may only read.
 
259
        """
228
260
        perms = set()
229
261
        if user is not None:
230
262
            perms.add('view')
231
 
        if user.rolenm == 'admin':
232
 
            perms.add('edit')
 
263
            if user.admin:
 
264
                perms.add('edit')
233
265
        return perms
234
266
 
 
267
    def active_offerings(self):
 
268
        """Find active offerings for this subject.
 
269
 
 
270
        Return a sequence of currently active offerings for this subject
 
271
        (offerings whose semester.state is "current"). There should be 0 or 1
 
272
        elements in this sequence, but it's possible there are more.
 
273
        """
 
274
        return self.offerings.find(Offering.semester_id == Semester.id,
 
275
                                   Semester.state == u'current')
 
276
 
 
277
    def offering_for_semester(self, year, semester):
 
278
        """Get the offering for the given year/semester, or None.
 
279
 
 
280
        @param year: A string representation of the year.
 
281
        @param semester: A string representation of the semester.
 
282
        """
 
283
        return self.offerings.find(Offering.semester_id == Semester.id,
 
284
                               Semester.year == unicode(year),
 
285
                               Semester.semester == unicode(semester)).one()
 
286
 
235
287
class Semester(Storm):
 
288
    """A semester in which subjects can be run."""
 
289
 
236
290
    __storm_table__ = "semester"
237
291
 
238
292
    id = Int(primary=True, name="semesterid")
239
293
    year = Unicode()
240
294
    semester = Unicode()
241
 
    active = Bool()
 
295
    state = Unicode()
242
296
 
243
297
    offerings = ReferenceSet(id, 'Offering.semester_id')
 
298
    enrolments = ReferenceSet(id,
 
299
                              'Offering.semester_id',
 
300
                              'Offering.id',
 
301
                              'Enrolment.offering_id')
244
302
 
245
303
    __init__ = _kwarg_init
246
304
 
248
306
        return "<%s %s/%s>" % (type(self).__name__, self.year, self.semester)
249
307
 
250
308
class Offering(Storm):
 
309
    """An offering of a subject in a particular semester."""
 
310
 
251
311
    __storm_table__ = "offering"
252
312
 
253
313
    id = Int(primary=True, name="offeringid")
264
324
                           'User.id')
265
325
    project_sets = ReferenceSet(id, 'ProjectSet.offering_id')
266
326
 
267
 
    worksheets = ReferenceSet(id, 'Worksheet.offering_id')
 
327
    worksheets = ReferenceSet(id, 
 
328
        'Worksheet.offering_id', 
 
329
        order_by="seq_no"
 
330
    )
268
331
 
269
332
    __init__ = _kwarg_init
270
333
 
272
335
        return "<%s %r in %r>" % (type(self).__name__, self.subject,
273
336
                                  self.semester)
274
337
 
275
 
    def enrol(self, user):
276
 
        '''Enrol a user in this offering.'''
277
 
        # We'll get a horrible database constraint violation error if we try
278
 
        # to add a second enrolment.
279
 
        if Store.of(self).find(Enrolment,
280
 
                               Enrolment.user_id == user.id,
281
 
                               Enrolment.offering_id == self.id).count() == 1:
282
 
            raise AlreadyEnrolledError()
283
 
 
284
 
        e = Enrolment(user=user, offering=self, active=True)
285
 
        self.enrolments.add(e)
 
338
    def enrol(self, user, role=u'student'):
 
339
        """Enrol a user in this offering.
 
340
 
 
341
        Enrolments handle both the staff and student cases. The role controls
 
342
        the privileges granted by this enrolment.
 
343
        """
 
344
        enrolment = Store.of(self).find(Enrolment,
 
345
                               Enrolment.user_id == user.id,
 
346
                               Enrolment.offering_id == self.id).one()
 
347
 
 
348
        if enrolment is None:
 
349
            enrolment = Enrolment(user=user, offering=self)
 
350
            self.enrolments.add(enrolment)
 
351
 
 
352
        enrolment.active = True
 
353
        enrolment.role = role
 
354
 
 
355
    def unenrol(self, user):
 
356
        '''Unenrol a user from this offering.'''
 
357
        enrolment = Store.of(self).find(Enrolment,
 
358
                               Enrolment.user_id == user.id,
 
359
                               Enrolment.offering_id == self.id).one()
 
360
        Store.of(enrolment).remove(enrolment)
 
361
 
 
362
    def get_permissions(self, user):
 
363
        perms = set()
 
364
        if user is not None:
 
365
            enrolment = self.get_enrolment(user)
 
366
            if enrolment or user.admin:
 
367
                perms.add('view')
 
368
            if (enrolment and enrolment.role in (u'tutor', u'lecturer')) \
 
369
               or user.admin:
 
370
                perms.add('edit')
 
371
        return perms
 
372
 
 
373
    def get_enrolment(self, user):
 
374
        """Find the user's enrolment in this offering."""
 
375
        try:
 
376
            enrolment = self.enrolments.find(user=user).one()
 
377
        except NotOneError:
 
378
            enrolment = None
 
379
 
 
380
        return enrolment
286
381
 
287
382
class Enrolment(Storm):
 
383
    """An enrolment of a user in an offering.
 
384
 
 
385
    This represents the roles of both staff and students.
 
386
    """
 
387
 
288
388
    __storm_table__ = "enrolment"
289
389
    __storm_primary__ = "user_id", "offering_id"
290
390
 
292
392
    user = Reference(user_id, User.id)
293
393
    offering_id = Int(name="offeringid")
294
394
    offering = Reference(offering_id, Offering.id)
 
395
    role = Unicode()
295
396
    notes = Unicode()
296
397
    active = Bool()
297
398
 
309
410
        return "<%s %r in %r>" % (type(self).__name__, self.user,
310
411
                                  self.offering)
311
412
 
312
 
class AlreadyEnrolledError(Exception):
313
 
    pass
314
 
 
315
413
# PROJECTS #
316
414
 
317
415
class ProjectSet(Storm):
 
416
    """A set of projects that share common groups.
 
417
 
 
418
    Each student project group is attached to a project set. The group is
 
419
    valid for all projects in the group's set.
 
420
    """
 
421
 
318
422
    __storm_table__ = "project_set"
319
423
 
320
424
    id = Int(name="projectsetid", primary=True)
331
435
        return "<%s %d in %r>" % (type(self).__name__, self.id,
332
436
                                  self.offering)
333
437
 
 
438
    def get_permissions(self, user):
 
439
        return self.offering.get_permissions(user)
 
440
 
334
441
class Project(Storm):
 
442
    """A student project for which submissions can be made."""
 
443
 
335
444
    __storm_table__ = "project"
336
445
 
337
446
    id = Int(name="projectid", primary=True)
 
447
    name = Unicode()
 
448
    short_name = Unicode()
338
449
    synopsis = Unicode()
339
450
    url = Unicode()
340
451
    project_set_id = Int(name="projectsetid")
341
452
    project_set = Reference(project_set_id, ProjectSet.id)
342
453
    deadline = DateTime()
343
454
 
 
455
    assesseds = ReferenceSet(id, 'Assessed.project_id')
 
456
    submissions = ReferenceSet(id,
 
457
                               'Assessed.project_id',
 
458
                               'Assessed.id',
 
459
                               'ProjectSubmission.assessed_id')
 
460
 
344
461
    __init__ = _kwarg_init
345
462
 
346
463
    def __repr__(self):
347
 
        return "<%s '%s' in %r>" % (type(self).__name__, self.synopsis,
 
464
        return "<%s '%s' in %r>" % (type(self).__name__, self.short_name,
348
465
                                  self.project_set.offering)
349
466
 
 
467
    def can_submit(self, principal):
 
468
        return (self in principal.get_projects() and
 
469
                self.deadline > datetime.datetime.now())
 
470
 
 
471
    def submit(self, principal, path, revision, who):
 
472
        """Submit a Subversion path and revision to a project.
 
473
 
 
474
        @param principal: The owner of the Subversion repository, and the
 
475
                          entity on behalf of whom the submission is being made
 
476
        @param path: A path within that repository to submit.
 
477
        @param revision: The revision of that path to submit.
 
478
        @param who: The user who is actually making the submission.
 
479
        """
 
480
 
 
481
        if not self.can_submit(principal):
 
482
            raise Exception('cannot submit')
 
483
 
 
484
        a = Assessed.get(Store.of(self), principal, self)
 
485
        ps = ProjectSubmission()
 
486
        ps.path = path
 
487
        ps.revision = revision
 
488
        ps.date_submitted = datetime.datetime.now()
 
489
        ps.assessed = a
 
490
        ps.submitter = who
 
491
 
 
492
        return ps
 
493
 
 
494
    def get_permissions(self, user):
 
495
        return self.project_set.offering.get_permissions(user)
 
496
 
 
497
 
350
498
class ProjectGroup(Storm):
 
499
    """A group of students working together on a project."""
 
500
 
351
501
    __storm_table__ = "project_group"
352
502
 
353
503
    id = Int(name="groupid", primary=True)
370
520
        return "<%s %s in %r>" % (type(self).__name__, self.name,
371
521
                                  self.project_set.offering)
372
522
 
 
523
    @property
 
524
    def display_name(self):
 
525
        return '%s (%s)' % (self.nick, self.name)
 
526
 
 
527
    def get_projects(self, offering=None, active_only=True):
 
528
        '''Find projects that the group can submit.
 
529
 
 
530
        This will include projects in the project set which owns this group,
 
531
        unless the project set disallows groups (in which case none will be
 
532
        returned).
 
533
 
 
534
        @param active_only: Whether to only search active offerings.
 
535
        @param offering: An optional offering to restrict the search to.
 
536
        '''
 
537
        return Store.of(self).find(Project,
 
538
            Project.project_set_id == ProjectSet.id,
 
539
            ProjectSet.id == self.project_set.id,
 
540
            ProjectSet.max_students_per_group != None,
 
541
            ProjectSet.offering_id == Offering.id,
 
542
            (offering is None) or (Offering.id == offering.id),
 
543
            Semester.id == Offering.semester_id,
 
544
            (not active_only) or (Semester.state == u'current'))
 
545
 
 
546
 
 
547
    def get_permissions(self, user):
 
548
        if user.admin or user in self.members:
 
549
            return set(['submit_project'])
 
550
        else:
 
551
            return set()
 
552
 
373
553
class ProjectGroupMembership(Storm):
 
554
    """A student's membership in a project group."""
 
555
 
374
556
    __storm_table__ = "group_member"
375
557
    __storm_primary__ = "user_id", "project_group_id"
376
558
 
385
567
        return "<%s %r in %r>" % (type(self).__name__, self.user,
386
568
                                  self.project_group)
387
569
 
 
570
class Assessed(Storm):
 
571
    """A composite of a user or group combined with a project.
 
572
 
 
573
    Each project submission and extension refers to an Assessed. It is the
 
574
    sole specifier of the repository and project.
 
575
    """
 
576
 
 
577
    __storm_table__ = "assessed"
 
578
 
 
579
    id = Int(name="assessedid", primary=True)
 
580
    user_id = Int(name="loginid")
 
581
    user = Reference(user_id, User.id)
 
582
    project_group_id = Int(name="groupid")
 
583
    project_group = Reference(project_group_id, ProjectGroup.id)
 
584
 
 
585
    project_id = Int(name="projectid")
 
586
    project = Reference(project_id, Project.id)
 
587
 
 
588
    extensions = ReferenceSet(id, 'ProjectExtension.assessed_id')
 
589
    submissions = ReferenceSet(id, 'ProjectSubmission.assessed_id')
 
590
 
 
591
    def __repr__(self):
 
592
        return "<%s %r in %r>" % (type(self).__name__,
 
593
            self.user or self.project_group, self.project)
 
594
 
 
595
    @classmethod
 
596
    def get(cls, store, principal, project):
 
597
        """Find or create an Assessed for the given user or group and project.
 
598
 
 
599
        @param principal: The user or group.
 
600
        @param project: The project.
 
601
        """
 
602
        t = type(principal)
 
603
        if t not in (User, ProjectGroup):
 
604
            raise AssertionError('principal must be User or ProjectGroup')
 
605
 
 
606
        a = store.find(cls,
 
607
            (t is User) or (cls.project_group_id == principal.id),
 
608
            (t is ProjectGroup) or (cls.user_id == principal.id),
 
609
            Project.id == project.id).one()
 
610
 
 
611
        if a is None:
 
612
            a = cls()
 
613
            if t is User:
 
614
                a.user = principal
 
615
            else:
 
616
                a.project_group = principal
 
617
            a.project = project
 
618
            store.add(a)
 
619
 
 
620
        return a
 
621
 
 
622
 
 
623
class ProjectExtension(Storm):
 
624
    """An extension granted to a user or group on a particular project.
 
625
 
 
626
    The user or group and project are specified by the Assessed.
 
627
    """
 
628
 
 
629
    __storm_table__ = "project_extension"
 
630
 
 
631
    id = Int(name="extensionid", primary=True)
 
632
    assessed_id = Int(name="assessedid")
 
633
    assessed = Reference(assessed_id, Assessed.id)
 
634
    deadline = DateTime()
 
635
    approver_id = Int(name="approver")
 
636
    approver = Reference(approver_id, User.id)
 
637
    notes = Unicode()
 
638
 
 
639
class ProjectSubmission(Storm):
 
640
    """A submission from a user or group repository to a particular project.
 
641
 
 
642
    The content of a submission is a single path and revision inside a
 
643
    repository. The repository is that owned by the submission's user and
 
644
    group, while the path and revision are explicit.
 
645
 
 
646
    The user or group and project are specified by the Assessed.
 
647
    """
 
648
 
 
649
    __storm_table__ = "project_submission"
 
650
 
 
651
    id = Int(name="submissionid", primary=True)
 
652
    assessed_id = Int(name="assessedid")
 
653
    assessed = Reference(assessed_id, Assessed.id)
 
654
    path = Unicode()
 
655
    revision = Int()
 
656
    submitter_id = Int(name="submitter")
 
657
    submitter = Reference(submitter_id, User.id)
 
658
    date_submitted = DateTime()
 
659
 
 
660
 
388
661
# WORKSHEETS AND EXERCISES #
389
662
 
390
663
class Exercise(Storm):
391
 
    # Note: Table "problem" is called "Exercise" in the Object layer, since
392
 
    # it's called that everywhere else.
393
 
    __storm_table__ = "problem"
394
 
#TODO: Add in a field for the user-friendly identifier
 
664
    """An exercise for students to complete in a worksheet.
 
665
 
 
666
    An exercise may be present in any number of worksheets.
 
667
    """
 
668
 
 
669
    __storm_table__ = "exercise"
395
670
    id = Unicode(primary=True, name="identifier")
396
671
    name = Unicode()
397
672
    description = Unicode()
400
675
    include = Unicode()
401
676
    num_rows = Int()
402
677
 
 
678
    worksheet_exercises =  ReferenceSet(id,
 
679
        'WorksheetExercise.exercise_id')
 
680
 
403
681
    worksheets = ReferenceSet(id,
404
682
        'WorksheetExercise.exercise_id',
405
683
        'WorksheetExercise.worksheet_id',
406
684
        'Worksheet.id'
407
685
    )
408
 
    
409
 
    test_suites = ReferenceSet(id, 'TestSuite.exercise_id')
 
686
 
 
687
    test_suites = ReferenceSet(id, 
 
688
        'TestSuite.exercise_id',
 
689
        order_by='seq_no')
410
690
 
411
691
    __init__ = _kwarg_init
412
692
 
413
693
    def __repr__(self):
414
694
        return "<%s %s>" % (type(self).__name__, self.name)
415
695
 
416
 
    @classmethod
417
 
    def get_by_name(cls, store, name):
418
 
        """
419
 
        Get the Exercise from the db associated with a given store and name.
420
 
        If the exercise is not in the database, creates it and inserts it
421
 
        automatically.
422
 
        """
423
 
        ex = store.find(cls, cls.name == unicode(name)).one()
424
 
        if ex is not None:
425
 
            return ex
426
 
        ex = Exercise(name=unicode(name))
427
 
        store.add(ex)
428
 
        store.commit()
429
 
        return ex
 
696
    def get_permissions(self, user):
 
697
        perms = set()
 
698
        roles = set()
 
699
        if user is not None:
 
700
            if user.admin:
 
701
                perms.add('edit')
 
702
                perms.add('view')
 
703
            elif u'lecturer' in set((e.role for e in user.active_enrolments)):
 
704
                perms.add('edit')
 
705
                perms.add('view')
 
706
            elif u'tutor' in set((e.role for e in user.active_enrolments)):
 
707
                perms.add('edit')
 
708
                perms.add('view')
 
709
 
 
710
        return perms
 
711
 
 
712
    def get_description(self):
 
713
        """Return the description interpreted as reStructuredText."""
 
714
        return rst(self.description)
 
715
 
 
716
    def delete(self):
 
717
        """Deletes the exercise, providing it has no associated worksheets."""
 
718
        if (self.worksheet_exercises.count() > 0):
 
719
            raise IntegrityError()
 
720
        for suite in self.test_suites:
 
721
            suite.delete()
 
722
        Store.of(self).remove(self)
430
723
 
431
724
class Worksheet(Storm):
 
725
    """A worksheet with exercises for students to complete.
 
726
 
 
727
    Worksheets are owned by offerings.
 
728
    """
 
729
 
432
730
    __storm_table__ = "worksheet"
433
731
 
434
732
    id = Int(primary=True, name="worksheetid")
435
 
    # XXX subject is not linked to a Subject object. This is a property of
436
 
    # the database, and will be refactored.
437
 
    subject = Unicode()
438
733
    offering_id = Int(name="offeringid")
439
 
    name = Unicode(name="identifier")
 
734
    identifier = Unicode()
 
735
    name = Unicode()
440
736
    assessable = Bool()
441
 
    mtime = DateTime()
 
737
    data = Unicode()
 
738
    seq_no = Int()
 
739
    format = Unicode()
442
740
 
 
741
    attempts = ReferenceSet(id, "ExerciseAttempt.worksheetid")
443
742
    offering = Reference(offering_id, 'Offering.id')
444
743
 
445
 
    exercises = ReferenceSet(id,
446
 
        'WorksheetExercise.worksheet_id',
447
 
        'WorksheetExercise.exercise_id',
448
 
        Exercise.id)
449
 
    # Use worksheet_exercises to get access to the WorksheetExercise objects
450
 
    # binding worksheets to exercises. This is required to access the
 
744
    all_worksheet_exercises = ReferenceSet(id,
 
745
        'WorksheetExercise.worksheet_id')
 
746
 
 
747
    # Use worksheet_exercises to get access to the *active* WorksheetExercise
 
748
    # objects binding worksheets to exercises. This is required to access the
451
749
    # "optional" field.
452
 
    worksheet_exercises = ReferenceSet(id,
453
 
        'WorksheetExercise.worksheet_id')
454
 
        
 
750
 
 
751
    @property
 
752
    def worksheet_exercises(self):
 
753
        return self.all_worksheet_exercises.find(active=True)
455
754
 
456
755
    __init__ = _kwarg_init
457
756
 
458
757
    def __repr__(self):
459
758
        return "<%s %s>" % (type(self).__name__, self.name)
460
759
 
461
 
    # XXX Refactor this - make it an instance method of Subject rather than a
462
 
    # class method of Worksheet. Can't do that now because Subject isn't
463
 
    # linked referentially to the Worksheet.
464
 
    @classmethod
465
 
    def get_by_name(cls, store, subjectname, worksheetname):
466
 
        """
467
 
        Get the Worksheet from the db associated with a given store, subject
468
 
        name and worksheet name.
469
 
        """
470
 
        return store.find(cls, cls.subject == unicode(subjectname),
471
 
            cls.name == unicode(worksheetname)).one()
 
760
    def remove_all_exercises(self):
 
761
        """Remove all exercises from this worksheet.
472
762
 
473
 
    def remove_all_exercises(self, store):
474
 
        """
475
 
        Remove all exercises from this worksheet.
476
763
        This does not delete the exercises themselves. It just removes them
477
764
        from the worksheet.
478
765
        """
 
766
        store = Store.of(self)
 
767
        for ws_ex in self.all_worksheet_exercises:
 
768
            if ws_ex.saves.count() > 0 or ws_ex.attempts.count() > 0:
 
769
                raise IntegrityError()
479
770
        store.find(WorksheetExercise,
480
771
            WorksheetExercise.worksheet == self).remove()
481
772
 
 
773
    def get_permissions(self, user):
 
774
        return self.offering.get_permissions(user)
 
775
 
 
776
    def get_xml(self):
 
777
        """Returns the xml of this worksheet, converts from rst if required."""
 
778
        if self.format == u'rst':
 
779
            ws_xml = rst(self.data)
 
780
            return ws_xml
 
781
        else:
 
782
            return self.data
 
783
 
 
784
    def delete(self):
 
785
        """Deletes the worksheet, provided it has no attempts on any exercises.
 
786
 
 
787
        Returns True if delete succeeded, or False if this worksheet has
 
788
        attempts attached."""
 
789
        for ws_ex in self.all_worksheet_exercises:
 
790
            if ws_ex.saves.count() > 0 or ws_ex.attempts.count() > 0:
 
791
                raise IntegrityError()
 
792
 
 
793
        self.remove_all_exercises()
 
794
        Store.of(self).remove(self)
 
795
 
482
796
class WorksheetExercise(Storm):
483
 
    __storm_table__ = "worksheet_problem"
484
 
    __storm_primary__ = "worksheet_id", "exercise_id"
 
797
    """A link between a worksheet and one of its exercises.
 
798
 
 
799
    These may be marked optional, in which case the exercise does not count
 
800
    for marking purposes. The sequence number is used to order the worksheet
 
801
    ToC.
 
802
    """
 
803
 
 
804
    __storm_table__ = "worksheet_exercise"
 
805
 
 
806
    id = Int(primary=True, name="ws_ex_id")
485
807
 
486
808
    worksheet_id = Int(name="worksheetid")
487
809
    worksheet = Reference(worksheet_id, Worksheet.id)
488
 
    exercise_id = Unicode(name="problemid")
 
810
    exercise_id = Unicode(name="exerciseid")
489
811
    exercise = Reference(exercise_id, Exercise.id)
490
812
    optional = Bool()
 
813
    active = Bool()
 
814
    seq_no = Int()
 
815
 
 
816
    saves = ReferenceSet(id, "ExerciseSave.ws_ex_id")
 
817
    attempts = ReferenceSet(id, "ExerciseAttempt.ws_ex_id")
491
818
 
492
819
    __init__ = _kwarg_init
493
820
 
494
821
    def __repr__(self):
495
822
        return "<%s %s in %s>" % (type(self).__name__, self.exercise.name,
496
 
                                  self.worksheet.name)
 
823
                                  self.worksheet.identifier)
 
824
 
 
825
    def get_permissions(self, user):
 
826
        return self.worksheet.get_permissions(user)
 
827
 
497
828
 
498
829
class ExerciseSave(Storm):
499
 
    """
500
 
    Represents a potential solution to an exercise that a user has submitted
501
 
    to the server for storage.
502
 
    A basic ExerciseSave is just the current saved text for this exercise for
503
 
    this user (doesn't count towards their attempts).
504
 
    ExerciseSave may be extended with additional semantics (such as
505
 
    ExerciseAttempt).
506
 
    """
507
 
    __storm_table__ = "problem_save"
508
 
    __storm_primary__ = "exercise_id", "user_id", "date"
509
 
 
510
 
    exercise_id = Unicode(name="problemid")
511
 
    exercise = Reference(exercise_id, Exercise.id)
 
830
    """A potential exercise solution submitted by a user for storage.
 
831
 
 
832
    This is not an actual tested attempt at an exercise, it's just a save of
 
833
    the editing session.
 
834
    """
 
835
 
 
836
    __storm_table__ = "exercise_save"
 
837
    __storm_primary__ = "ws_ex_id", "user_id"
 
838
 
 
839
    ws_ex_id = Int(name="ws_ex_id")
 
840
    worksheet_exercise = Reference(ws_ex_id, "WorksheetExercise.id")
 
841
 
512
842
    user_id = Int(name="loginid")
513
843
    user = Reference(user_id, User.id)
514
844
    date = DateTime()
515
845
    text = Unicode()
516
 
    worksheetid = Int()
517
 
    worksheet = Reference(worksheetid, Worksheet.id)
518
846
 
519
847
    __init__ = _kwarg_init
520
848
 
523
851
            self.exercise.name, self.user.login, self.date.strftime("%c"))
524
852
 
525
853
class ExerciseAttempt(ExerciseSave):
526
 
    """
527
 
    An ExerciseAttempt is a special case of an ExerciseSave. Like an
528
 
    ExerciseSave, it constitutes exercise solution data that the user has
529
 
    submitted to the server for storage.
530
 
    In addition, it contains additional information about the submission.
531
 
    complete - True if this submission was successful, rendering this exercise
532
 
        complete for this user.
533
 
    active - True if this submission is "active" (usually true). Submissions
534
 
        may be de-activated by privileged users for special reasons, and then
535
 
        they won't count (either as a penalty or success), but will still be
536
 
        stored.
537
 
    """
538
 
    __storm_table__ = "problem_attempt"
539
 
    __storm_primary__ = "exercise_id", "user_id", "date"
 
854
    """An attempt at solving an exercise.
 
855
 
 
856
    This is a special case of ExerciseSave, used when the user submits a
 
857
    candidate solution. Like an ExerciseSave, it constitutes exercise solution
 
858
    data.
 
859
 
 
860
    In addition, it contains information about the result of the submission:
 
861
 
 
862
     - complete - True if this submission was successful, rendering this
 
863
                  exercise complete for this user in this worksheet.
 
864
     - active   - True if this submission is "active" (usually true).
 
865
                  Submissions may be de-activated by privileged users for
 
866
                  special reasons, and then they won't count (either as a
 
867
                  penalty or success), but will still be stored.
 
868
    """
 
869
 
 
870
    __storm_table__ = "exercise_attempt"
 
871
    __storm_primary__ = "ws_ex_id", "user_id", "date"
540
872
 
541
873
    # The "text" field is the same but has a different name in the DB table
542
874
    # for some reason.
543
875
    text = Unicode(name="attempt")
544
876
    complete = Bool()
545
877
    active = Bool()
546
 
    
 
878
 
547
879
    def get_permissions(self, user):
548
880
        return set(['view']) if user is self.user else set()
549
 
  
 
881
 
550
882
class TestSuite(Storm):
551
 
    """A Testsuite acts as a container for the test cases of an exercise."""
 
883
    """A container to group an exercise's test cases.
 
884
 
 
885
    The test suite contains some information on how to test. The function to
 
886
    test, variables to set and stdin data are stored here.
 
887
    """
 
888
 
552
889
    __storm_table__ = "test_suite"
553
890
    __storm_primary__ = "exercise_id", "suiteid"
554
 
    
 
891
 
555
892
    suiteid = Int()
556
 
    exercise_id = Unicode(name="problemid")
557
 
    exercise = Reference(exercise_id, Exercise.id)
558
 
    test_cases = ReferenceSet(suiteid, 'TestCase.suiteid')
 
893
    exercise_id = Unicode(name="exerciseid")
559
894
    description = Unicode()
560
895
    seq_no = Int()
 
896
    function = Unicode()
 
897
    stdin = Unicode()
 
898
    exercise = Reference(exercise_id, Exercise.id)
 
899
    test_cases = ReferenceSet(suiteid, 'TestCase.suiteid', order_by="seq_no")
 
900
    variables = ReferenceSet(suiteid, 'TestSuiteVar.suiteid', order_by='arg_no')
 
901
 
 
902
    def delete(self):
 
903
        """Delete this suite, without asking questions."""
 
904
        for vaariable in self.variables:
 
905
            variable.delete()
 
906
        for test_case in self.test_cases:
 
907
            test_case.delete()
 
908
        Store.of(self).remove(self)
561
909
 
562
910
class TestCase(Storm):
563
 
    """A TestCase is a member of a TestSuite.
564
 
    
565
 
    It contains the data necessary to check if an exercise is correct"""
 
911
    """A container for actual tests (see TestCasePart), inside a test suite.
 
912
 
 
913
    It is the lowest level shown to students on their pass/fail status."""
 
914
 
566
915
    __storm_table__ = "test_case"
567
916
    __storm_primary__ = "testid", "suiteid"
568
 
    
 
917
 
569
918
    testid = Int()
570
919
    suiteid = Int()
571
 
    suite = Reference(suiteid, TestSuite.suiteid)
 
920
    suite = Reference(suiteid, "TestSuite.suiteid")
572
921
    passmsg = Unicode()
573
922
    failmsg = Unicode()
574
 
    init = Unicode()
575
 
    code_type = Unicode()
576
 
    code = Unicode()
577
 
    testtype = Unicode()
 
923
    test_default = Unicode()
578
924
    seq_no = Int()
579
 
    
580
 
    __init__ = _kwarg_init
 
925
 
 
926
    parts = ReferenceSet(testid, "TestCasePart.testid")
 
927
 
 
928
    __init__ = _kwarg_init
 
929
 
 
930
    def delete(self):
 
931
        for part in self.parts:
 
932
            part.delete()
 
933
        Store.of(self).remove(self)
 
934
 
 
935
class TestSuiteVar(Storm):
 
936
    """A variable used by an exercise test suite.
 
937
 
 
938
    This may represent a function argument or a normal variable.
 
939
    """
 
940
 
 
941
    __storm_table__ = "suite_variable"
 
942
    __storm_primary__ = "varid"
 
943
 
 
944
    varid = Int()
 
945
    suiteid = Int()
 
946
    var_name = Unicode()
 
947
    var_value = Unicode()
 
948
    var_type = Unicode()
 
949
    arg_no = Int()
 
950
 
 
951
    suite = Reference(suiteid, "TestSuite.suiteid")
 
952
 
 
953
    __init__ = _kwarg_init
 
954
 
 
955
    def delete(self):
 
956
        Store.of(self).remove(self)
 
957
 
 
958
class TestCasePart(Storm):
 
959
    """An actual piece of code to test an exercise solution."""
 
960
 
 
961
    __storm_table__ = "test_case_part"
 
962
    __storm_primary__ = "partid"
 
963
 
 
964
    partid = Int()
 
965
    testid = Int()
 
966
 
 
967
    part_type = Unicode()
 
968
    test_type = Unicode()
 
969
    data = Unicode()
 
970
    filename = Unicode()
 
971
 
 
972
    test = Reference(testid, "TestCase.testid")
 
973
 
 
974
    __init__ = _kwarg_init
 
975
 
 
976
    def delete(self):
 
977
        Store.of(self).remove(self)