← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ivle/database.py

Merged from trunk

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
 
"""Database utilities and content classes.
 
20
"""
 
21
Database Classes and Utilities for Storm ORM
21
22
 
22
23
This module provides all of the classes which map to database tables.
23
24
It also provides miscellaneous utility functions for database interaction.
24
25
"""
25
26
 
26
 
import hashlib
 
27
import md5
27
28
import datetime
28
29
 
29
30
from storm.locals import create_database, Store, Int, Unicode, DateTime, \
30
31
                         Reference, ReferenceSet, Bool, Storm, Desc
31
 
from storm.exceptions import NotOneError, IntegrityError
32
32
 
 
33
import ivle.conf
33
34
from ivle.worksheet.rst import rst
34
35
 
35
36
__all__ = ['get_store',
36
37
            'User',
37
38
            'Subject', 'Semester', 'Offering', 'Enrolment',
38
39
            'ProjectSet', 'Project', 'ProjectGroup', 'ProjectGroupMembership',
39
 
            'Assessed', 'ProjectSubmission', 'ProjectExtension',
40
40
            'Exercise', 'Worksheet', 'WorksheetExercise',
41
41
            'ExerciseSave', 'ExerciseAttempt',
42
42
            'TestCase', 'TestSuite', 'TestSuiteVar'
49
49
                % (self.__class__.__name__, k))
50
50
        setattr(self, k, v)
51
51
 
52
 
def get_conn_string(config):
53
 
    """Create a Storm connection string to the IVLE database
54
 
 
55
 
    @param config: The IVLE configuration.
 
52
def get_conn_string():
 
53
    """
 
54
    Returns the Storm connection string, generated from the conf file.
56
55
    """
57
56
 
58
57
    clusterstr = ''
59
 
    if config['database']['username']:
60
 
        clusterstr += config['database']['username']
61
 
        if config['database']['password']:
62
 
            clusterstr += ':' + config['database']['password']
 
58
    if ivle.conf.db_user:
 
59
        clusterstr += ivle.conf.db_user
 
60
        if ivle.conf.db_password:
 
61
            clusterstr += ':' + ivle.conf.db_password
63
62
        clusterstr += '@'
64
63
 
65
 
    host = config['database']['host'] or 'localhost'
66
 
    port = config['database']['port'] or 5432
 
64
    host = ivle.conf.db_host or 'localhost'
 
65
    port = ivle.conf.db_port or 5432
67
66
 
68
67
    clusterstr += '%s:%d' % (host, port)
69
68
 
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)))
 
69
    return "postgres://%s/%s" % (clusterstr, ivle.conf.db_dbname)
 
70
 
 
71
def get_store():
 
72
    """
 
73
    Open a database connection and transaction. Return a storm.store.Store
 
74
    instance connected to the configured IVLE database.
 
75
    """
 
76
    return Store(create_database(get_conn_string()))
78
77
 
79
78
# USERS #
80
79
 
81
80
class User(Storm):
82
 
    """An IVLE user account."""
 
81
    """
 
82
    Represents an IVLE user.
 
83
    """
83
84
    __storm_table__ = "login"
84
85
 
85
86
    id = Int(primary=True, name="loginid")
115
116
        return self.hash_password(password) == self.passhash
116
117
 
117
118
    @property
118
 
    def display_name(self):
119
 
        return self.fullname
120
 
 
121
 
    @property
122
119
    def password_expired(self):
123
120
        fieldval = self.pass_exp
124
121
        return fieldval is not None and datetime.datetime.now() > fieldval
161
158
 
162
159
    # TODO: Invitations should be listed too?
163
160
    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
 
        """
168
161
        preds = [
169
162
            ProjectGroupMembership.user_id == self.id,
170
163
            ProjectGroup.id == ProjectGroupMembership.project_group_id,
190
183
        '''A sanely ordered list of all of the user's enrolments.'''
191
184
        return self._get_enrolments(False) 
192
185
 
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
 
 
213
186
    @staticmethod
214
187
    def hash_password(password):
215
 
        """Hash a password with MD5."""
216
 
        return hashlib.md5(password).hexdigest()
 
188
        return md5.md5(password).hexdigest()
217
189
 
218
190
    @classmethod
219
191
    def get_by_login(cls, store, login):
220
 
        """Find a user in a store by login name."""
 
192
        """
 
193
        Get the User from the db associated with a given store and
 
194
        login.
 
195
        """
221
196
        return store.find(cls, cls.login == unicode(login)).one()
222
197
 
223
198
    def get_permissions(self, user):
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
199
        if user and user.admin or user is self:
230
 
            return set(['view', 'edit', 'submit_project'])
 
200
            return set(['view', 'edit'])
231
201
        else:
232
202
            return set()
233
203
 
234
204
# SUBJECTS AND ENROLMENTS #
235
205
 
236
206
class Subject(Storm):
237
 
    """A subject (or course) which is run in some semesters."""
238
 
 
239
207
    __storm_table__ = "subject"
240
208
 
241
209
    id = Int(primary=True, name="subjectid")
252
220
        return "<%s '%s'>" % (type(self).__name__, self.short_name)
253
221
 
254
222
    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
 
        """
260
223
        perms = set()
261
224
        if user is not None:
262
225
            perms.add('view')
264
227
                perms.add('edit')
265
228
        return perms
266
229
 
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
 
 
287
230
class Semester(Storm):
288
 
    """A semester in which subjects can be run."""
289
 
 
290
231
    __storm_table__ = "semester"
291
232
 
292
233
    id = Int(primary=True, name="semesterid")
295
236
    state = Unicode()
296
237
 
297
238
    offerings = ReferenceSet(id, 'Offering.semester_id')
298
 
    enrolments = ReferenceSet(id,
299
 
                              'Offering.semester_id',
300
 
                              'Offering.id',
301
 
                              'Enrolment.offering_id')
302
239
 
303
240
    __init__ = _kwarg_init
304
241
 
306
243
        return "<%s %s/%s>" % (type(self).__name__, self.year, self.semester)
307
244
 
308
245
class Offering(Storm):
309
 
    """An offering of a subject in a particular semester."""
310
 
 
311
246
    __storm_table__ = "offering"
312
247
 
313
248
    id = Int(primary=True, name="offeringid")
336
271
                                  self.semester)
337
272
 
338
273
    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
 
        """
 
274
        '''Enrol a user in this offering.'''
344
275
        enrolment = Store.of(self).find(Enrolment,
345
276
                               Enrolment.user_id == user.id,
346
277
                               Enrolment.offering_id == self.id).one()
352
283
        enrolment.active = True
353
284
        enrolment.role = role
354
285
 
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
286
    def get_permissions(self, user):
363
287
        perms = set()
364
288
        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:
 
289
            perms.add('view')
 
290
            if user.admin:
370
291
                perms.add('edit')
371
292
        return perms
372
293
 
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
381
 
 
382
294
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
 
 
388
295
    __storm_table__ = "enrolment"
389
296
    __storm_primary__ = "user_id", "offering_id"
390
297
 
413
320
# PROJECTS #
414
321
 
415
322
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
 
 
422
323
    __storm_table__ = "project_set"
423
324
 
424
325
    id = Int(name="projectsetid", primary=True)
435
336
        return "<%s %d in %r>" % (type(self).__name__, self.id,
436
337
                                  self.offering)
437
338
 
438
 
    def get_permissions(self, user):
439
 
        return self.offering.get_permissions(user)
440
 
 
441
339
class Project(Storm):
442
 
    """A student project for which submissions can be made."""
443
 
 
444
340
    __storm_table__ = "project"
445
341
 
446
342
    id = Int(name="projectid", primary=True)
447
 
    name = Unicode()
448
 
    short_name = Unicode()
449
343
    synopsis = Unicode()
450
344
    url = Unicode()
451
345
    project_set_id = Int(name="projectsetid")
452
346
    project_set = Reference(project_set_id, ProjectSet.id)
453
347
    deadline = DateTime()
454
348
 
455
 
    assesseds = ReferenceSet(id, 'Assessed.project_id')
456
 
    submissions = ReferenceSet(id,
457
 
                               'Assessed.project_id',
458
 
                               'Assessed.id',
459
 
                               'ProjectSubmission.assessed_id')
460
 
 
461
349
    __init__ = _kwarg_init
462
350
 
463
351
    def __repr__(self):
464
 
        return "<%s '%s' in %r>" % (type(self).__name__, self.short_name,
 
352
        return "<%s '%s' in %r>" % (type(self).__name__, self.synopsis,
465
353
                                  self.project_set.offering)
466
354
 
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
 
 
498
355
class ProjectGroup(Storm):
499
 
    """A group of students working together on a project."""
500
 
 
501
356
    __storm_table__ = "project_group"
502
357
 
503
358
    id = Int(name="groupid", primary=True)
520
375
        return "<%s %s in %r>" % (type(self).__name__, self.name,
521
376
                                  self.project_set.offering)
522
377
 
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
 
 
553
378
class ProjectGroupMembership(Storm):
554
 
    """A student's membership in a project group."""
555
 
 
556
379
    __storm_table__ = "group_member"
557
380
    __storm_primary__ = "user_id", "project_group_id"
558
381
 
567
390
        return "<%s %r in %r>" % (type(self).__name__, self.user,
568
391
                                  self.project_group)
569
392
 
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
 
 
661
393
# WORKSHEETS AND EXERCISES #
662
394
 
663
395
class Exercise(Storm):
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
396
    __storm_table__ = "exercise"
670
397
    id = Unicode(primary=True, name="identifier")
671
398
    name = Unicode()
675
402
    include = Unicode()
676
403
    num_rows = Int()
677
404
 
678
 
    worksheet_exercises =  ReferenceSet(id,
679
 
        'WorksheetExercise.exercise_id')
680
 
 
681
405
    worksheets = ReferenceSet(id,
682
406
        'WorksheetExercise.exercise_id',
683
407
        'WorksheetExercise.worksheet_id',
684
408
        'Worksheet.id'
685
409
    )
686
 
 
 
410
    
687
411
    test_suites = ReferenceSet(id, 
688
412
        'TestSuite.exercise_id',
689
413
        order_by='seq_no')
695
419
 
696
420
    def get_permissions(self, user):
697
421
        perms = set()
698
 
        roles = set()
699
422
        if user is not None:
700
423
            if user.admin:
701
424
                perms.add('edit')
702
425
                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
426
        return perms
711
427
 
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)
723
 
 
724
428
class Worksheet(Storm):
725
 
    """A worksheet with exercises for students to complete.
726
 
 
727
 
    Worksheets are owned by offerings.
728
 
    """
729
 
 
730
429
    __storm_table__ = "worksheet"
731
430
 
732
431
    id = Int(primary=True, name="worksheetid")
757
456
    def __repr__(self):
758
457
        return "<%s %s>" % (type(self).__name__, self.name)
759
458
 
760
 
    def remove_all_exercises(self):
761
 
        """Remove all exercises from this worksheet.
 
459
    # XXX Refactor this - make it an instance method of Subject rather than a
 
460
    # class method of Worksheet. Can't do that now because Subject isn't
 
461
    # linked referentially to the Worksheet.
 
462
    @classmethod
 
463
    def get_by_name(cls, store, subjectname, worksheetname):
 
464
        """
 
465
        Get the Worksheet from the db associated with a given store, subject
 
466
        name and worksheet name.
 
467
        """
 
468
        return store.find(cls, cls.subject == unicode(subjectname),
 
469
            cls.name == unicode(worksheetname)).one()
762
470
 
 
471
    def remove_all_exercises(self, store):
 
472
        """
 
473
        Remove all exercises from this worksheet.
763
474
        This does not delete the exercises themselves. It just removes them
764
475
        from the worksheet.
765
476
        """
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()
770
477
        store.find(WorksheetExercise,
771
478
            WorksheetExercise.worksheet == self).remove()
772
 
 
 
479
            
773
480
    def get_permissions(self, user):
774
481
        return self.offering.get_permissions(user)
775
 
 
 
482
    
776
483
    def get_xml(self):
777
484
        """Returns the xml of this worksheet, converts from rst if required."""
778
485
        if self.format == u'rst':
779
 
            ws_xml = rst(self.data)
 
486
            ws_xml = '<worksheet>' + rst(self.data) + '</worksheet>'
780
487
            return ws_xml
781
488
        else:
782
489
            return self.data
783
490
 
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
 
 
796
491
class WorksheetExercise(Storm):
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
492
    __storm_table__ = "worksheet_exercise"
805
 
 
 
493
    
806
494
    id = Int(primary=True, name="ws_ex_id")
807
495
 
808
496
    worksheet_id = Int(name="worksheetid")
812
500
    optional = Bool()
813
501
    active = Bool()
814
502
    seq_no = Int()
815
 
 
 
503
    
816
504
    saves = ReferenceSet(id, "ExerciseSave.ws_ex_id")
817
505
    attempts = ReferenceSet(id, "ExerciseAttempt.ws_ex_id")
818
506
 
822
510
        return "<%s %s in %s>" % (type(self).__name__, self.exercise.name,
823
511
                                  self.worksheet.identifier)
824
512
 
825
 
    def get_permissions(self, user):
826
 
        return self.worksheet.get_permissions(user)
827
 
 
828
 
 
829
513
class ExerciseSave(Storm):
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
 
 
 
514
    """
 
515
    Represents a potential solution to an exercise that a user has submitted
 
516
    to the server for storage.
 
517
    A basic ExerciseSave is just the current saved text for this exercise for
 
518
    this user (doesn't count towards their attempts).
 
519
    ExerciseSave may be extended with additional semantics (such as
 
520
    ExerciseAttempt).
 
521
    """
836
522
    __storm_table__ = "exercise_save"
837
523
    __storm_primary__ = "ws_ex_id", "user_id"
838
524
 
851
537
            self.exercise.name, self.user.login, self.date.strftime("%c"))
852
538
 
853
539
class ExerciseAttempt(ExerciseSave):
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
 
 
 
540
    """
 
541
    An ExerciseAttempt is a special case of an ExerciseSave. Like an
 
542
    ExerciseSave, it constitutes exercise solution data that the user has
 
543
    submitted to the server for storage.
 
544
    In addition, it contains additional information about the submission.
 
545
    complete - True if this submission was successful, rendering this exercise
 
546
        complete for this user.
 
547
    active - True if this submission is "active" (usually true). Submissions
 
548
        may be de-activated by privileged users for special reasons, and then
 
549
        they won't count (either as a penalty or success), but will still be
 
550
        stored.
 
551
    """
870
552
    __storm_table__ = "exercise_attempt"
871
553
    __storm_primary__ = "ws_ex_id", "user_id", "date"
872
554
 
875
557
    text = Unicode(name="attempt")
876
558
    complete = Bool()
877
559
    active = Bool()
878
 
 
 
560
    
879
561
    def get_permissions(self, user):
880
562
        return set(['view']) if user is self.user else set()
881
 
 
 
563
  
882
564
class TestSuite(Storm):
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
 
 
 
565
    """A Testsuite acts as a container for the test cases of an exercise."""
889
566
    __storm_table__ = "test_suite"
890
567
    __storm_primary__ = "exercise_id", "suiteid"
891
 
 
 
568
    
892
569
    suiteid = Int()
893
570
    exercise_id = Unicode(name="exerciseid")
894
571
    description = Unicode()
899
576
    test_cases = ReferenceSet(suiteid, 'TestCase.suiteid', order_by="seq_no")
900
577
    variables = ReferenceSet(suiteid, 'TestSuiteVar.suiteid', order_by='arg_no')
901
578
 
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)
909
 
 
910
579
class TestCase(Storm):
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
 
 
 
580
    """A TestCase is a member of a TestSuite.
 
581
    
 
582
    It contains the data necessary to check if an exercise is correct"""
915
583
    __storm_table__ = "test_case"
916
584
    __storm_primary__ = "testid", "suiteid"
917
 
 
 
585
    
918
586
    testid = Int()
919
587
    suiteid = Int()
920
588
    suite = Reference(suiteid, "TestSuite.suiteid")
922
590
    failmsg = Unicode()
923
591
    test_default = Unicode()
924
592
    seq_no = Int()
925
 
 
 
593
    
926
594
    parts = ReferenceSet(testid, "TestCasePart.testid")
927
 
 
 
595
    
928
596
    __init__ = _kwarg_init
929
597
 
930
 
    def delete(self):
931
 
        for part in self.parts:
932
 
            part.delete()
933
 
        Store.of(self).remove(self)
934
 
 
935
598
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
 
 
 
599
    """A container for the arguments of a Test Suite"""
941
600
    __storm_table__ = "suite_variable"
942
601
    __storm_primary__ = "varid"
943
 
 
 
602
    
944
603
    varid = Int()
945
604
    suiteid = Int()
946
605
    var_name = Unicode()
947
606
    var_value = Unicode()
948
607
    var_type = Unicode()
949
608
    arg_no = Int()
950
 
 
 
609
    
951
610
    suite = Reference(suiteid, "TestSuite.suiteid")
952
 
 
 
611
    
953
612
    __init__ = _kwarg_init
954
 
 
955
 
    def delete(self):
956
 
        Store.of(self).remove(self)
957
 
 
 
613
    
958
614
class TestCasePart(Storm):
959
 
    """An actual piece of code to test an exercise solution."""
960
 
 
 
615
    """A container for the test elements of a Test Case"""
961
616
    __storm_table__ = "test_case_part"
962
617
    __storm_primary__ = "partid"
963
 
 
 
618
    
964
619
    partid = Int()
965
620
    testid = Int()
966
 
 
 
621
    
967
622
    part_type = Unicode()
968
623
    test_type = Unicode()
969
624
    data = Unicode()
970
625
    filename = Unicode()
971
 
 
 
626
    
972
627
    test = Reference(testid, "TestCase.testid")
973
 
 
 
628
    
974
629
    __init__ = _kwarg_init
975
 
 
976
 
    def delete(self):
977
 
        Store.of(self).remove(self)