← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ivle/database.py

Merge from new-dispatch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/database.py
24
24
It also provides miscellaneous utility functions for database interaction.
25
25
"""
26
26
 
27
 
import hashlib
 
27
import md5
28
28
import datetime
29
29
 
30
30
from storm.locals import create_database, Store, Int, Unicode, DateTime, \
31
31
                         Reference, ReferenceSet, Bool, Storm, Desc
32
 
from storm.exceptions import NotOneError, IntegrityError
33
32
 
34
 
from ivle.worksheet.rst import rst
 
33
import ivle.conf
 
34
import ivle.caps
35
35
 
36
36
__all__ = ['get_store',
37
37
            'User',
38
38
            'Subject', 'Semester', 'Offering', 'Enrolment',
39
39
            'ProjectSet', 'Project', 'ProjectGroup', 'ProjectGroupMembership',
40
 
            'Assessed', 'ProjectSubmission', 'ProjectExtension',
41
40
            'Exercise', 'Worksheet', 'WorksheetExercise',
42
41
            'ExerciseSave', 'ExerciseAttempt',
43
 
            'TestCase', 'TestSuite', 'TestSuiteVar'
 
42
            'AlreadyEnrolledError'
44
43
        ]
45
44
 
46
45
def _kwarg_init(self, **kwargs):
50
49
                % (self.__class__.__name__, k))
51
50
        setattr(self, k, v)
52
51
 
53
 
def get_conn_string(config):
54
 
    """Create a Storm connection string to the IVLE database
55
 
 
56
 
    @param config: The IVLE configuration.
57
 
    """
58
 
 
59
 
    clusterstr = ''
60
 
    if config['database']['username']:
61
 
        clusterstr += config['database']['username']
62
 
        if config['database']['password']:
63
 
            clusterstr += ':' + config['database']['password']
64
 
        clusterstr += '@'
65
 
 
66
 
    host = config['database']['host'] or 'localhost'
67
 
    port = config['database']['port'] or 5432
68
 
 
69
 
    clusterstr += '%s:%d' % (host, port)
70
 
 
71
 
    return "postgres://%s/%s" % (clusterstr, config['database']['name'])
72
 
 
73
 
def get_store(config):
74
 
    """Create a Storm store connected to the IVLE database.
75
 
 
76
 
    @param config: The IVLE configuration.
77
 
    """
78
 
    return Store(create_database(get_conn_string(config)))
 
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()))
79
66
 
80
67
# USERS #
81
68
 
89
76
    login = Unicode()
90
77
    passhash = Unicode()
91
78
    state = Unicode()
92
 
    admin = Bool()
 
79
    rolenm = Unicode()
93
80
    unixid = Int()
94
81
    nick = Unicode()
95
82
    pass_exp = DateTime()
101
88
    studentid = Unicode()
102
89
    settings = Unicode()
103
90
 
 
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
 
104
101
    __init__ = _kwarg_init
105
102
 
106
103
    def __repr__(self):
117
114
            return None
118
115
        return self.hash_password(password) == self.passhash
119
116
 
120
 
    @property
121
 
    def display_name(self):
122
 
        return self.fullname
 
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)
123
122
 
124
123
    @property
125
124
    def password_expired(self):
131
130
        fieldval = self.acct_exp
132
131
        return fieldval is not None and datetime.datetime.now() > fieldval
133
132
 
134
 
    @property
135
 
    def valid(self):
136
 
        return self.state == 'enabled' and not self.account_expired
137
 
 
138
133
    def _get_enrolments(self, justactive):
139
134
        return Store.of(self).find(Enrolment,
140
135
            Enrolment.user_id == self.id,
189
184
        '''A sanely ordered list of all of the user's enrolments.'''
190
185
        return self._get_enrolments(False) 
191
186
 
192
 
    def get_projects(self, offering=None, active_only=True):
193
 
        '''Return Projects that the user can submit.
194
 
 
195
 
        This will include projects for offerings in which the user is
196
 
        enrolled, as long as the project is not in a project set which has
197
 
        groups (ie. if maximum number of group members is 0).
198
 
 
199
 
        Unless active_only is False, only projects for active offerings will
200
 
        be returned.
201
 
 
202
 
        If an offering is specified, returned projects will be limited to
203
 
        those for that offering.
204
 
        '''
205
 
        return Store.of(self).find(Project,
206
 
            Project.project_set_id == ProjectSet.id,
207
 
            ProjectSet.max_students_per_group == None,
208
 
            ProjectSet.offering_id == Offering.id,
209
 
            (offering is None) or (Offering.id == offering.id),
210
 
            Semester.id == Offering.semester_id,
211
 
            (not active_only) or (Semester.state == u'current'),
212
 
            Enrolment.offering_id == Offering.id,
213
 
            Enrolment.user_id == self.id)
214
 
 
215
187
    @staticmethod
216
188
    def hash_password(password):
217
 
        return hashlib.md5(password).hexdigest()
 
189
        return md5.md5(password).hexdigest()
218
190
 
219
191
    @classmethod
220
192
    def get_by_login(cls, store, login):
225
197
        return store.find(cls, cls.login == unicode(login)).one()
226
198
 
227
199
    def get_permissions(self, user):
228
 
        if user and user.admin or user is self:
229
 
            return set(['view', 'edit', 'submit_project'])
 
200
        if user and user.rolenm == 'admin' or user is self:
 
201
            return set(['view', 'edit'])
230
202
        else:
231
203
            return set()
232
204
 
252
224
        perms = set()
253
225
        if user is not None:
254
226
            perms.add('view')
255
 
            if user.admin:
256
 
                perms.add('edit')
 
227
        if user.rolenm == 'admin':
 
228
            perms.add('edit')
257
229
        return perms
258
230
 
259
 
    def active_offerings(self):
260
 
        """Return a sequence of currently active offerings for this subject
261
 
        (offerings whose semester.state is "current"). There should be 0 or 1
262
 
        elements in this sequence, but it's possible there are more.
263
 
        """
264
 
        return self.offerings.find(Offering.semester_id == Semester.id,
265
 
                                   Semester.state == u'current')
266
 
 
267
 
    def offering_for_semester(self, year, semester):
268
 
        """Get the offering for the given year/semester, or None."""
269
 
        return self.offerings.find(Offering.semester_id == Semester.id,
270
 
                               Semester.year == unicode(year),
271
 
                               Semester.semester == unicode(semester)).one()
272
 
 
273
231
class Semester(Storm):
274
232
    __storm_table__ = "semester"
275
233
 
276
234
    id = Int(primary=True, name="semesterid")
277
235
    year = Unicode()
278
236
    semester = Unicode()
279
 
    state = Unicode()
 
237
    active = Bool()
280
238
 
281
239
    offerings = ReferenceSet(id, 'Offering.semester_id')
282
 
    enrolments = ReferenceSet(id,
283
 
                              'Offering.semester_id',
284
 
                              'Offering.id',
285
 
                              'Enrolment.offering_id')
286
240
 
287
241
    __init__ = _kwarg_init
288
242
 
306
260
                           'User.id')
307
261
    project_sets = ReferenceSet(id, 'ProjectSet.offering_id')
308
262
 
309
 
    worksheets = ReferenceSet(id, 
310
 
        'Worksheet.offering_id', 
311
 
        order_by="seq_no"
312
 
    )
313
 
 
314
263
    __init__ = _kwarg_init
315
264
 
316
265
    def __repr__(self):
317
266
        return "<%s %r in %r>" % (type(self).__name__, self.subject,
318
267
                                  self.semester)
319
268
 
320
 
    def enrol(self, user, role=u'student'):
 
269
    def enrol(self, user):
321
270
        '''Enrol a user in this offering.'''
322
 
        enrolment = Store.of(self).find(Enrolment,
323
 
                               Enrolment.user_id == user.id,
324
 
                               Enrolment.offering_id == self.id).one()
325
 
 
326
 
        if enrolment is None:
327
 
            enrolment = Enrolment(user=user, offering=self)
328
 
            self.enrolments.add(enrolment)
329
 
 
330
 
        enrolment.active = True
331
 
        enrolment.role = role
332
 
 
333
 
    def unenrol(self, user):
334
 
        '''Unenrol a user from this offering.'''
335
 
        enrolment = Store.of(self).find(Enrolment,
336
 
                               Enrolment.user_id == user.id,
337
 
                               Enrolment.offering_id == self.id).one()
338
 
        Store.of(enrolment).remove(enrolment)
339
 
 
340
 
    def get_permissions(self, user):
341
 
        perms = set()
342
 
        if user is not None:
343
 
            enrolment = self.get_enrolment(user)
344
 
            if enrolment or user.admin:
345
 
                perms.add('view')
346
 
            if (enrolment and enrolment.role in (u'tutor', u'lecturer')) \
347
 
               or user.admin:
348
 
                perms.add('edit')
349
 
        return perms
350
 
 
351
 
    def get_enrolment(self, user):
352
 
        try:
353
 
            enrolment = self.enrolments.find(user=user).one()
354
 
        except NotOneError:
355
 
            enrolment = None
356
 
 
357
 
        return enrolment
 
271
        # We'll get a horrible database constraint violation error if we try
 
272
        # to add a second enrolment.
 
273
        if Store.of(self).find(Enrolment,
 
274
                               Enrolment.user_id == user.id,
 
275
                               Enrolment.offering_id == self.id).count() == 1:
 
276
            raise AlreadyEnrolledError()
 
277
 
 
278
        e = Enrolment(user=user, offering=self, active=True)
 
279
        self.enrolments.add(e)
358
280
 
359
281
class Enrolment(Storm):
360
282
    __storm_table__ = "enrolment"
364
286
    user = Reference(user_id, User.id)
365
287
    offering_id = Int(name="offeringid")
366
288
    offering = Reference(offering_id, Offering.id)
367
 
    role = Unicode()
368
289
    notes = Unicode()
369
290
    active = Bool()
370
291
 
382
303
        return "<%s %r in %r>" % (type(self).__name__, self.user,
383
304
                                  self.offering)
384
305
 
 
306
class AlreadyEnrolledError(Exception):
 
307
    pass
 
308
 
385
309
# PROJECTS #
386
310
 
387
311
class ProjectSet(Storm):
405
329
    __storm_table__ = "project"
406
330
 
407
331
    id = Int(name="projectid", primary=True)
408
 
    name = Unicode()
409
 
    short_name = Unicode()
410
332
    synopsis = Unicode()
411
333
    url = Unicode()
412
334
    project_set_id = Int(name="projectsetid")
413
335
    project_set = Reference(project_set_id, ProjectSet.id)
414
336
    deadline = DateTime()
415
337
 
416
 
    assesseds = ReferenceSet(id, 'Assessed.project_id')
417
 
    submissions = ReferenceSet(id,
418
 
                               'Assessed.project_id',
419
 
                               'Assessed.id',
420
 
                               'ProjectSubmission.assessed_id')
421
 
 
422
338
    __init__ = _kwarg_init
423
339
 
424
340
    def __repr__(self):
425
 
        return "<%s '%s' in %r>" % (type(self).__name__, self.short_name,
 
341
        return "<%s '%s' in %r>" % (type(self).__name__, self.synopsis,
426
342
                                  self.project_set.offering)
427
343
 
428
 
    def can_submit(self, principal):
429
 
        return (self in principal.get_projects() and
430
 
                self.deadline > datetime.datetime.now())
431
 
 
432
 
    def submit(self, principal, path, revision, who):
433
 
        """Submit a Subversion path and revision to a project.
434
 
 
435
 
        'principal' is the owner of the Subversion repository, and the
436
 
        entity on behalf of whom the submission is being made. 'path' is
437
 
        a path within that repository, and 'revision' specifies which
438
 
        revision of that path. 'who' is the person making the submission.
439
 
        """
440
 
 
441
 
        if not self.can_submit(principal):
442
 
            raise Exception('cannot submit')
443
 
 
444
 
        a = Assessed.get(Store.of(self), principal, self)
445
 
        ps = ProjectSubmission()
446
 
        ps.path = path
447
 
        ps.revision = revision
448
 
        ps.date_submitted = datetime.datetime.now()
449
 
        ps.assessed = a
450
 
        ps.submitter = who
451
 
 
452
 
        return ps
453
 
 
454
 
 
455
344
class ProjectGroup(Storm):
456
345
    __storm_table__ = "project_group"
457
346
 
475
364
        return "<%s %s in %r>" % (type(self).__name__, self.name,
476
365
                                  self.project_set.offering)
477
366
 
478
 
    @property
479
 
    def display_name(self):
480
 
        return '%s (%s)' % (self.nick, self.name)
481
 
 
482
 
    def get_projects(self, offering=None, active_only=True):
483
 
        '''Return Projects that the group can submit.
484
 
 
485
 
        This will include projects in the project set which owns this group,
486
 
        unless the project set disallows groups (in which case none will be
487
 
        returned).
488
 
 
489
 
        Unless active_only is False, projects will only be returned if the
490
 
        group's offering is active.
491
 
 
492
 
        If an offering is specified, projects will only be returned if it
493
 
        matches the group's.
494
 
        '''
495
 
        return Store.of(self).find(Project,
496
 
            Project.project_set_id == ProjectSet.id,
497
 
            ProjectSet.id == self.project_set.id,
498
 
            ProjectSet.max_students_per_group != None,
499
 
            ProjectSet.offering_id == Offering.id,
500
 
            (offering is None) or (Offering.id == offering.id),
501
 
            Semester.id == Offering.semester_id,
502
 
            (not active_only) or (Semester.state == u'current'))
503
 
 
504
 
 
505
 
    def get_permissions(self, user):
506
 
        if user.admin or user in self.members:
507
 
            return set(['submit_project'])
508
 
        else:
509
 
            return set()
510
 
 
511
367
class ProjectGroupMembership(Storm):
512
368
    __storm_table__ = "group_member"
513
369
    __storm_primary__ = "user_id", "project_group_id"
523
379
        return "<%s %r in %r>" % (type(self).__name__, self.user,
524
380
                                  self.project_group)
525
381
 
526
 
class Assessed(Storm):
527
 
    __storm_table__ = "assessed"
528
 
 
529
 
    id = Int(name="assessedid", primary=True)
530
 
    user_id = Int(name="loginid")
531
 
    user = Reference(user_id, User.id)
532
 
    project_group_id = Int(name="groupid")
533
 
    project_group = Reference(project_group_id, ProjectGroup.id)
534
 
 
535
 
    project_id = Int(name="projectid")
536
 
    project = Reference(project_id, Project.id)
537
 
 
538
 
    extensions = ReferenceSet(id, 'ProjectExtension.assessed_id')
539
 
    submissions = ReferenceSet(id, 'ProjectSubmission.assessed_id')
540
 
 
541
 
    def __repr__(self):
542
 
        return "<%s %r in %r>" % (type(self).__name__,
543
 
            self.user or self.project_group, self.project)
544
 
 
545
 
    @classmethod
546
 
    def get(cls, store, principal, project):
547
 
        t = type(principal)
548
 
        if t not in (User, ProjectGroup):
549
 
            raise AssertionError('principal must be User or ProjectGroup')
550
 
 
551
 
        a = store.find(cls,
552
 
            (t is User) or (cls.project_group_id == principal.id),
553
 
            (t is ProjectGroup) or (cls.user_id == principal.id),
554
 
            Project.id == project.id).one()
555
 
 
556
 
        if a is None:
557
 
            a = cls()
558
 
            if t is User:
559
 
                a.user = principal
560
 
            else:
561
 
                a.project_group = principal
562
 
            a.project = project
563
 
            store.add(a)
564
 
 
565
 
        return a
566
 
 
567
 
 
568
 
class ProjectExtension(Storm):
569
 
    __storm_table__ = "project_extension"
570
 
 
571
 
    id = Int(name="extensionid", primary=True)
572
 
    assessed_id = Int(name="assessedid")
573
 
    assessed = Reference(assessed_id, Assessed.id)
574
 
    deadline = DateTime()
575
 
    approver_id = Int(name="approver")
576
 
    approver = Reference(approver_id, User.id)
577
 
    notes = Unicode()
578
 
 
579
 
class ProjectSubmission(Storm):
580
 
    __storm_table__ = "project_submission"
581
 
 
582
 
    id = Int(name="submissionid", primary=True)
583
 
    assessed_id = Int(name="assessedid")
584
 
    assessed = Reference(assessed_id, Assessed.id)
585
 
    path = Unicode()
586
 
    revision = Int()
587
 
    submitter_id = Int(name="submitter")
588
 
    submitter = Reference(submitter_id, User.id)
589
 
    date_submitted = DateTime()
590
 
 
591
 
 
592
382
# WORKSHEETS AND EXERCISES #
593
383
 
594
384
class Exercise(Storm):
595
 
    __storm_table__ = "exercise"
596
 
    id = Unicode(primary=True, name="identifier")
597
 
    name = Unicode()
598
 
    description = Unicode()
599
 
    partial = Unicode()
600
 
    solution = Unicode()
601
 
    include = Unicode()
602
 
    num_rows = Int()
 
385
    # Note: Table "problem" is called "Exercise" in the Object layer, since
 
386
    # it's called that everywhere else.
 
387
    __storm_table__ = "problem"
603
388
 
604
 
    worksheet_exercises =  ReferenceSet(id,
605
 
        'WorksheetExercise.exercise_id')
 
389
    id = Int(primary=True, name="problemid")
 
390
    name = Unicode(name="identifier")
 
391
    spec = Unicode()
606
392
 
607
393
    worksheets = ReferenceSet(id,
608
394
        'WorksheetExercise.exercise_id',
609
395
        'WorksheetExercise.worksheet_id',
610
396
        'Worksheet.id'
611
397
    )
612
 
    
613
 
    test_suites = ReferenceSet(id, 
614
 
        'TestSuite.exercise_id',
615
 
        order_by='seq_no')
616
398
 
617
399
    __init__ = _kwarg_init
618
400
 
619
401
    def __repr__(self):
620
402
        return "<%s %s>" % (type(self).__name__, self.name)
621
403
 
622
 
    def get_permissions(self, user):
623
 
        perms = set()
624
 
        roles = set()
625
 
        if user is not None:
626
 
            if user.admin:
627
 
                perms.add('edit')
628
 
                perms.add('view')
629
 
            elif 'lecturer' in set((e.role for e in user.active_enrolments)):
630
 
                perms.add('edit')
631
 
                perms.add('view')
632
 
            
633
 
        return perms
634
 
    
635
 
    def get_description(self):
636
 
        return rst(self.description)
637
 
 
638
 
    def delete(self):
639
 
        """Deletes the exercise, providing it has no associated worksheets."""
640
 
        if (self.worksheet_exercises.count() > 0):
641
 
            raise IntegrityError()
642
 
        for suite in self.test_suites:
643
 
            suite.delete()
644
 
        Store.of(self).remove(self)
 
404
    @classmethod
 
405
    def get_by_name(cls, store, name):
 
406
        """
 
407
        Get the Exercise from the db associated with a given store and name.
 
408
        If the exercise is not in the database, creates it and inserts it
 
409
        automatically.
 
410
        """
 
411
        ex = store.find(cls, cls.name == unicode(name)).one()
 
412
        if ex is not None:
 
413
            return ex
 
414
        ex = Exercise(name=unicode(name))
 
415
        store.add(ex)
 
416
        store.commit()
 
417
        return ex
645
418
 
646
419
class Worksheet(Storm):
647
420
    __storm_table__ = "worksheet"
648
421
 
649
422
    id = Int(primary=True, name="worksheetid")
650
 
    offering_id = Int(name="offeringid")
651
 
    identifier = Unicode()
652
 
    name = Unicode()
 
423
    # XXX subject is not linked to a Subject object. This is a property of
 
424
    # the database, and will be refactored.
 
425
    subject = Unicode()
 
426
    name = Unicode(name="identifier")
653
427
    assessable = Bool()
654
 
    data = Unicode()
655
 
    seq_no = Int()
656
 
    format = Unicode()
657
 
 
658
 
    attempts = ReferenceSet(id, "ExerciseAttempt.worksheetid")
659
 
    offering = Reference(offering_id, 'Offering.id')
660
 
 
661
 
    all_worksheet_exercises = ReferenceSet(id,
 
428
    mtime = DateTime()
 
429
 
 
430
    exercises = ReferenceSet(id,
 
431
        'WorksheetExercise.worksheet_id',
 
432
        'WorksheetExercise.exercise_id',
 
433
        Exercise.id)
 
434
    # Use worksheet_exercises to get access to the WorksheetExercise objects
 
435
    # binding worksheets to exercises. This is required to access the
 
436
    # "optional" field.
 
437
    worksheet_exercises = ReferenceSet(id,
662
438
        'WorksheetExercise.worksheet_id')
663
439
 
664
 
    # Use worksheet_exercises to get access to the *active* WorksheetExercise
665
 
    # objects binding worksheets to exercises. This is required to access the
666
 
    # "optional" field.
667
 
 
668
 
    @property
669
 
    def worksheet_exercises(self):
670
 
        return self.all_worksheet_exercises.find(active=True)
671
 
 
672
440
    __init__ = _kwarg_init
673
441
 
674
442
    def __repr__(self):
675
443
        return "<%s %s>" % (type(self).__name__, self.name)
676
444
 
677
 
    def remove_all_exercises(self):
 
445
    # XXX Refactor this - make it an instance method of Subject rather than a
 
446
    # class method of Worksheet. Can't do that now because Subject isn't
 
447
    # linked referentially to the Worksheet.
 
448
    @classmethod
 
449
    def get_by_name(cls, store, subjectname, worksheetname):
 
450
        """
 
451
        Get the Worksheet from the db associated with a given store, subject
 
452
        name and worksheet name.
 
453
        """
 
454
        return store.find(cls, cls.subject == unicode(subjectname),
 
455
            cls.name == unicode(worksheetname)).one()
 
456
 
 
457
    def remove_all_exercises(self, store):
678
458
        """
679
459
        Remove all exercises from this worksheet.
680
460
        This does not delete the exercises themselves. It just removes them
681
461
        from the worksheet.
682
462
        """
683
 
        store = Store.of(self)
684
 
        for ws_ex in self.all_worksheet_exercises:
685
 
            if ws_ex.saves.count() > 0 or ws_ex.attempts.count() > 0:
686
 
                raise IntegrityError()
687
463
        store.find(WorksheetExercise,
688
464
            WorksheetExercise.worksheet == self).remove()
689
 
            
690
 
    def get_permissions(self, user):
691
 
        return self.offering.get_permissions(user)
692
 
    
693
 
    def get_xml(self):
694
 
        """Returns the xml of this worksheet, converts from rst if required."""
695
 
        if self.format == u'rst':
696
 
            ws_xml = rst(self.data)
697
 
            return ws_xml
698
 
        else:
699
 
            return self.data
700
 
    
701
 
    def delete(self):
702
 
        """Deletes the worksheet, provided it has no attempts on any exercises.
703
 
        
704
 
        Returns True if delete succeeded, or False if this worksheet has
705
 
        attempts attached."""
706
 
        for ws_ex in self.all_worksheet_exercises:
707
 
            if ws_ex.saves.count() > 0 or ws_ex.attempts.count() > 0:
708
 
                raise IntegrityError()
709
 
        
710
 
        self.remove_all_exercises()
711
 
        Store.of(self).remove(self)
712
 
        
 
465
 
713
466
class WorksheetExercise(Storm):
714
 
    __storm_table__ = "worksheet_exercise"
715
 
    
716
 
    id = Int(primary=True, name="ws_ex_id")
 
467
    __storm_table__ = "worksheet_problem"
 
468
    __storm_primary__ = "worksheet_id", "exercise_id"
717
469
 
718
470
    worksheet_id = Int(name="worksheetid")
719
471
    worksheet = Reference(worksheet_id, Worksheet.id)
720
 
    exercise_id = Unicode(name="exerciseid")
 
472
    exercise_id = Int(name="problemid")
721
473
    exercise = Reference(exercise_id, Exercise.id)
722
474
    optional = Bool()
723
 
    active = Bool()
724
 
    seq_no = Int()
725
 
    
726
 
    saves = ReferenceSet(id, "ExerciseSave.ws_ex_id")
727
 
    attempts = ReferenceSet(id, "ExerciseAttempt.ws_ex_id")
728
475
 
729
476
    __init__ = _kwarg_init
730
477
 
731
478
    def __repr__(self):
732
479
        return "<%s %s in %s>" % (type(self).__name__, self.exercise.name,
733
 
                                  self.worksheet.identifier)
734
 
 
735
 
    def get_permissions(self, user):
736
 
        return self.worksheet.get_permissions(user)
737
 
    
 
480
                                  self.worksheet.name)
738
481
 
739
482
class ExerciseSave(Storm):
740
483
    """
745
488
    ExerciseSave may be extended with additional semantics (such as
746
489
    ExerciseAttempt).
747
490
    """
748
 
    __storm_table__ = "exercise_save"
749
 
    __storm_primary__ = "ws_ex_id", "user_id"
750
 
 
751
 
    ws_ex_id = Int(name="ws_ex_id")
752
 
    worksheet_exercise = Reference(ws_ex_id, "WorksheetExercise.id")
753
 
 
 
491
    __storm_table__ = "problem_save"
 
492
    __storm_primary__ = "exercise_id", "user_id", "date"
 
493
 
 
494
    exercise_id = Int(name="problemid")
 
495
    exercise = Reference(exercise_id, Exercise.id)
754
496
    user_id = Int(name="loginid")
755
497
    user = Reference(user_id, User.id)
756
498
    date = DateTime()
775
517
        they won't count (either as a penalty or success), but will still be
776
518
        stored.
777
519
    """
778
 
    __storm_table__ = "exercise_attempt"
779
 
    __storm_primary__ = "ws_ex_id", "user_id", "date"
 
520
    __storm_table__ = "problem_attempt"
 
521
    __storm_primary__ = "exercise_id", "user_id", "date"
780
522
 
781
523
    # The "text" field is the same but has a different name in the DB table
782
524
    # for some reason.
783
525
    text = Unicode(name="attempt")
784
526
    complete = Bool()
785
527
    active = Bool()
786
 
    
 
528
 
787
529
    def get_permissions(self, user):
788
530
        return set(['view']) if user is self.user else set()
789
 
  
790
 
class TestSuite(Storm):
791
 
    """A Testsuite acts as a container for the test cases of an exercise."""
792
 
    __storm_table__ = "test_suite"
793
 
    __storm_primary__ = "exercise_id", "suiteid"
794
 
    
795
 
    suiteid = Int()
796
 
    exercise_id = Unicode(name="exerciseid")
797
 
    description = Unicode()
798
 
    seq_no = Int()
799
 
    function = Unicode()
800
 
    stdin = Unicode()
801
 
    exercise = Reference(exercise_id, Exercise.id)
802
 
    test_cases = ReferenceSet(suiteid, 'TestCase.suiteid', order_by="seq_no")
803
 
    variables = ReferenceSet(suiteid, 'TestSuiteVar.suiteid', order_by='arg_no')
804
 
    
805
 
    def delete(self):
806
 
        """Delete this suite, without asking questions."""
807
 
        for vaariable in self.variables:
808
 
            variable.delete()
809
 
        for test_case in self.test_cases:
810
 
            test_case.delete()
811
 
        Store.of(self).remove(self)
812
 
 
813
 
class TestCase(Storm):
814
 
    """A TestCase is a member of a TestSuite.
815
 
    
816
 
    It contains the data necessary to check if an exercise is correct"""
817
 
    __storm_table__ = "test_case"
818
 
    __storm_primary__ = "testid", "suiteid"
819
 
    
820
 
    testid = Int()
821
 
    suiteid = Int()
822
 
    suite = Reference(suiteid, "TestSuite.suiteid")
823
 
    passmsg = Unicode()
824
 
    failmsg = Unicode()
825
 
    test_default = Unicode()
826
 
    seq_no = Int()
827
 
    
828
 
    parts = ReferenceSet(testid, "TestCasePart.testid")
829
 
    
830
 
    __init__ = _kwarg_init
831
 
    
832
 
    def delete(self):
833
 
        for part in self.parts:
834
 
            part.delete()
835
 
        Store.of(self).remove(self)
836
 
 
837
 
class TestSuiteVar(Storm):
838
 
    """A container for the arguments of a Test Suite"""
839
 
    __storm_table__ = "suite_variable"
840
 
    __storm_primary__ = "varid"
841
 
    
842
 
    varid = Int()
843
 
    suiteid = Int()
844
 
    var_name = Unicode()
845
 
    var_value = Unicode()
846
 
    var_type = Unicode()
847
 
    arg_no = Int()
848
 
    
849
 
    suite = Reference(suiteid, "TestSuite.suiteid")
850
 
    
851
 
    __init__ = _kwarg_init
852
 
    
853
 
    def delete(self):
854
 
        Store.of(self).remove(self)
855
 
    
856
 
class TestCasePart(Storm):
857
 
    """A container for the test elements of a Test Case"""
858
 
    __storm_table__ = "test_case_part"
859
 
    __storm_primary__ = "partid"
860
 
    
861
 
    partid = Int()
862
 
    testid = Int()
863
 
    
864
 
    part_type = Unicode()
865
 
    test_type = Unicode()
866
 
    data = Unicode()
867
 
    filename = Unicode()
868
 
    
869
 
    test = Reference(testid, "TestCase.testid")
870
 
    
871
 
    __init__ = _kwarg_init
872
 
    
873
 
    def delete(self):
874
 
        Store.of(self).remove(self)