← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ivle/database.py

  • Committer: William Grant
  • Date: 2010-02-11 05:09:56 UTC
  • Revision ID: grantw@unimelb.edu.au-20100211050956-t5i2z6b8iulxteza
Unbreak existing tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/database.py
17
17
 
18
18
# Author: Matt Giuca, Will Grant
19
19
 
20
 
"""
21
 
Database Classes and Utilities for Storm ORM
 
20
"""Database utilities and content classes.
22
21
 
23
22
This module provides all of the classes which map to database tables.
24
23
It also provides miscellaneous utility functions for database interaction.
25
24
"""
26
25
 
27
 
import md5
 
26
import hashlib
28
27
import datetime
29
28
 
30
29
from storm.locals import create_database, Store, Int, Unicode, DateTime, \
31
30
                         Reference, ReferenceSet, Bool, Storm, Desc
32
 
 
33
 
import ivle.conf
34
 
import ivle.caps
 
31
from storm.expr import Select, Max
 
32
from storm.exceptions import NotOneError, IntegrityError
 
33
 
 
34
from ivle.worksheet.rst import rst
 
35
 
 
36
__all__ = ['get_store',
 
37
            'User',
 
38
            'Subject', 'Semester', 'Offering', 'Enrolment',
 
39
            'ProjectSet', 'Project', 'ProjectGroup', 'ProjectGroupMembership',
 
40
            'Assessed', 'ProjectSubmission', 'ProjectExtension',
 
41
            'Exercise', 'Worksheet', 'WorksheetExercise',
 
42
            'ExerciseSave', 'ExerciseAttempt',
 
43
            'TestCase', 'TestSuite', 'TestSuiteVar'
 
44
        ]
35
45
 
36
46
def _kwarg_init(self, **kwargs):
37
47
    for k,v in kwargs.items():
38
 
        if k.startswith('_') or not hasattr(self, k):
 
48
        if k.startswith('_') or not hasattr(self.__class__, k):
39
49
            raise TypeError("%s got an unexpected keyword argument '%s'"
40
 
                % self.__class__.__name__, k)
 
50
                % (self.__class__.__name__, k))
41
51
        setattr(self, k, v)
42
52
 
43
 
def get_conn_string():
44
 
    """
45
 
    Returns the Storm connection string, generated from the conf file.
46
 
    """
47
 
    return "postgres://%s:%s@%s:%d/%s" % (ivle.conf.db_user,
48
 
        ivle.conf.db_password, ivle.conf.db_host, ivle.conf.db_port,
49
 
        ivle.conf.db_dbname)
50
 
 
51
 
def get_store():
52
 
    """
53
 
    Open a database connection and transaction. Return a storm.store.Store
54
 
    instance connected to the configured IVLE database.
55
 
    """
56
 
    return Store(create_database(get_conn_string()))
 
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)))
 
79
 
 
80
# USERS #
57
81
 
58
82
class User(Storm):
59
 
    """
60
 
    Represents an IVLE user.
61
 
    """
 
83
    """An IVLE user account."""
62
84
    __storm_table__ = "login"
63
85
 
64
86
    id = Int(primary=True, name="loginid")
65
87
    login = Unicode()
66
88
    passhash = Unicode()
67
89
    state = Unicode()
68
 
    rolenm = Unicode()
 
90
    admin = Bool()
69
91
    unixid = Int()
70
92
    nick = Unicode()
71
93
    pass_exp = DateTime()
77
99
    studentid = Unicode()
78
100
    settings = Unicode()
79
101
 
80
 
    def _get_role(self):
81
 
        if self.rolenm is None:
82
 
            return None
83
 
        return ivle.caps.Role(self.rolenm)
84
 
    def _set_role(self, value):
85
 
        if not isinstance(value, ivle.caps.Role):
86
 
            raise TypeError("role must be an ivle.caps.Role")
87
 
        self.rolenm = unicode(value)
88
 
    role = property(_get_role, _set_role)
89
 
 
90
102
    __init__ = _kwarg_init
91
103
 
92
104
    def __repr__(self):
103
115
            return None
104
116
        return self.hash_password(password) == self.passhash
105
117
 
106
 
    def hasCap(self, capability):
107
 
        """Given a capability (which is a Role object), returns True if this
108
 
        User has that capability, False otherwise.
109
 
        """
110
 
        return self.role.hasCap(capability)
 
118
    @property
 
119
    def display_name(self):
 
120
        """Returns the "nice name" of the user or group."""
 
121
        return self.fullname
 
122
 
 
123
    @property
 
124
    def short_name(self):
 
125
        """Returns the database "identifier" name of the user or group."""
 
126
        return self.login
111
127
 
112
128
    @property
113
129
    def password_expired(self):
119
135
        fieldval = self.acct_exp
120
136
        return fieldval is not None and datetime.datetime.now() > fieldval
121
137
 
 
138
    @property
 
139
    def valid(self):
 
140
        return self.state == 'enabled' and not self.account_expired
 
141
 
122
142
    def _get_enrolments(self, justactive):
123
143
        return Store.of(self).find(Enrolment,
124
144
            Enrolment.user_id == self.id,
131
151
                Desc(Subject.code)
132
152
            )
133
153
 
 
154
    def _set_password(self, password):
 
155
        if password is None:
 
156
            self.passhash = None
 
157
        else:
 
158
            self.passhash = unicode(User.hash_password(password))
 
159
    password = property(fset=_set_password)
 
160
 
134
161
    @property
135
162
    def subjects(self):
136
163
        return Store.of(self).find(Subject,
139
166
            Offering.id == Enrolment.offering_id,
140
167
            Subject.id == Offering.subject_id).config(distinct=True)
141
168
 
 
169
    # TODO: Invitations should be listed too?
 
170
    def get_groups(self, offering=None):
 
171
        """Get groups of which this user is a member.
 
172
 
 
173
        @param offering: An optional offering to restrict the search to.
 
174
        """
 
175
        preds = [
 
176
            ProjectGroupMembership.user_id == self.id,
 
177
            ProjectGroup.id == ProjectGroupMembership.project_group_id,
 
178
        ]
 
179
        if offering:
 
180
            preds.extend([
 
181
                ProjectSet.offering_id == offering.id,
 
182
                ProjectGroup.project_set_id == ProjectSet.id,
 
183
            ])
 
184
        return Store.of(self).find(ProjectGroup, *preds)
 
185
 
 
186
    @property
 
187
    def groups(self):
 
188
        return self.get_groups()
 
189
 
142
190
    @property
143
191
    def active_enrolments(self):
144
192
        '''A sanely ordered list of the user's active enrolments.'''
149
197
        '''A sanely ordered list of all of the user's enrolments.'''
150
198
        return self._get_enrolments(False) 
151
199
 
 
200
    def get_projects(self, offering=None, active_only=True):
 
201
        """Find projects that the user can submit.
 
202
 
 
203
        This will include projects for offerings in which the user is
 
204
        enrolled, as long as the project is not in a project set which has
 
205
        groups (ie. if maximum number of group members is 0).
 
206
 
 
207
        @param active_only: Whether to only search active offerings.
 
208
        @param offering: An optional offering to restrict the search to.
 
209
        """
 
210
        return Store.of(self).find(Project,
 
211
            Project.project_set_id == ProjectSet.id,
 
212
            ProjectSet.max_students_per_group == None,
 
213
            ProjectSet.offering_id == Offering.id,
 
214
            (offering is None) or (Offering.id == offering.id),
 
215
            Semester.id == Offering.semester_id,
 
216
            (not active_only) or (Semester.state == u'current'),
 
217
            Enrolment.offering_id == Offering.id,
 
218
            Enrolment.user_id == self.id)
 
219
 
152
220
    @staticmethod
153
221
    def hash_password(password):
154
 
        return md5.md5(password).hexdigest()
 
222
        """Hash a password with MD5."""
 
223
        return hashlib.md5(password).hexdigest()
155
224
 
156
225
    @classmethod
157
226
    def get_by_login(cls, store, login):
158
 
        """
159
 
        Get the User from the db associated with a given store and
160
 
        login.
161
 
        """
 
227
        """Find a user in a store by login name."""
162
228
        return store.find(cls, cls.login == unicode(login)).one()
163
229
 
 
230
    def get_permissions(self, user):
 
231
        """Determine privileges held by a user over this object.
 
232
 
 
233
        If the user requesting privileges is this user or an admin,
 
234
        they may do everything. Otherwise they may do nothing.
 
235
        """
 
236
        if user and user.admin or user is self:
 
237
            return set(['view_public', 'view', 'edit', 'submit_project'])
 
238
        else:
 
239
            return set(['view_public'])
 
240
 
 
241
# SUBJECTS AND ENROLMENTS #
 
242
 
164
243
class Subject(Storm):
 
244
    """A subject (or course) which is run in some semesters."""
 
245
 
165
246
    __storm_table__ = "subject"
166
247
 
167
248
    id = Int(primary=True, name="subjectid")
168
249
    code = Unicode(name="subj_code")
169
250
    name = Unicode(name="subj_name")
170
251
    short_name = Unicode(name="subj_short_name")
171
 
    url = Unicode()
172
252
 
173
253
    offerings = ReferenceSet(id, 'Offering.subject_id')
174
254
 
177
257
    def __repr__(self):
178
258
        return "<%s '%s'>" % (type(self).__name__, self.short_name)
179
259
 
 
260
    def get_permissions(self, user):
 
261
        """Determine privileges held by a user over this object.
 
262
 
 
263
        If the user requesting privileges is an admin, they may edit.
 
264
        Otherwise they may only read.
 
265
        """
 
266
        perms = set()
 
267
        if user is not None:
 
268
            perms.add('view')
 
269
            if user.admin:
 
270
                perms.add('edit')
 
271
        return perms
 
272
 
 
273
    def active_offerings(self):
 
274
        """Find active offerings for this subject.
 
275
 
 
276
        Return a sequence of currently active offerings for this subject
 
277
        (offerings whose semester.state is "current"). There should be 0 or 1
 
278
        elements in this sequence, but it's possible there are more.
 
279
        """
 
280
        return self.offerings.find(Offering.semester_id == Semester.id,
 
281
                                   Semester.state == u'current')
 
282
 
 
283
    def offering_for_semester(self, year, semester):
 
284
        """Get the offering for the given year/semester, or None.
 
285
 
 
286
        @param year: A string representation of the year.
 
287
        @param semester: A string representation of the semester.
 
288
        """
 
289
        return self.offerings.find(Offering.semester_id == Semester.id,
 
290
                               Semester.year == unicode(year),
 
291
                               Semester.semester == unicode(semester)).one()
 
292
 
180
293
class Semester(Storm):
 
294
    """A semester in which subjects can be run."""
 
295
 
181
296
    __storm_table__ = "semester"
182
297
 
183
298
    id = Int(primary=True, name="semesterid")
184
299
    year = Unicode()
185
300
    semester = Unicode()
186
 
    active = Bool()
 
301
    state = Unicode()
187
302
 
188
303
    offerings = ReferenceSet(id, 'Offering.semester_id')
 
304
    enrolments = ReferenceSet(id,
 
305
                              'Offering.semester_id',
 
306
                              'Offering.id',
 
307
                              'Enrolment.offering_id')
189
308
 
190
309
    __init__ = _kwarg_init
191
310
 
193
312
        return "<%s %s/%s>" % (type(self).__name__, self.year, self.semester)
194
313
 
195
314
class Offering(Storm):
 
315
    """An offering of a subject in a particular semester."""
 
316
 
196
317
    __storm_table__ = "offering"
197
318
 
198
319
    id = Int(primary=True, name="offeringid")
200
321
    subject = Reference(subject_id, Subject.id)
201
322
    semester_id = Int(name="semesterid")
202
323
    semester = Reference(semester_id, Semester.id)
 
324
    description = Unicode()
 
325
    url = Unicode()
203
326
    groups_student_permissions = Unicode()
204
327
 
205
328
    enrolments = ReferenceSet(id, 'Enrolment.offering_id')
 
329
    members = ReferenceSet(id,
 
330
                           'Enrolment.offering_id',
 
331
                           'Enrolment.user_id',
 
332
                           'User.id')
 
333
    project_sets = ReferenceSet(id, 'ProjectSet.offering_id')
 
334
    projects = ReferenceSet(id,
 
335
                            'ProjectSet.offering_id',
 
336
                            'ProjectSet.id',
 
337
                            'Project.project_set_id')
 
338
 
 
339
    worksheets = ReferenceSet(id, 
 
340
        'Worksheet.offering_id', 
 
341
        order_by="seq_no"
 
342
    )
206
343
 
207
344
    __init__ = _kwarg_init
208
345
 
210
347
        return "<%s %r in %r>" % (type(self).__name__, self.subject,
211
348
                                  self.semester)
212
349
 
 
350
    def enrol(self, user, role=u'student'):
 
351
        """Enrol a user in this offering.
 
352
 
 
353
        Enrolments handle both the staff and student cases. The role controls
 
354
        the privileges granted by this enrolment.
 
355
        """
 
356
        enrolment = Store.of(self).find(Enrolment,
 
357
                               Enrolment.user_id == user.id,
 
358
                               Enrolment.offering_id == self.id).one()
 
359
 
 
360
        if enrolment is None:
 
361
            enrolment = Enrolment(user=user, offering=self)
 
362
            self.enrolments.add(enrolment)
 
363
 
 
364
        enrolment.active = True
 
365
        enrolment.role = role
 
366
 
 
367
    def unenrol(self, user):
 
368
        '''Unenrol a user from this offering.'''
 
369
        enrolment = Store.of(self).find(Enrolment,
 
370
                               Enrolment.user_id == user.id,
 
371
                               Enrolment.offering_id == self.id).one()
 
372
        Store.of(enrolment).remove(enrolment)
 
373
 
 
374
    def get_permissions(self, user):
 
375
        perms = set()
 
376
        if user is not None:
 
377
            enrolment = self.get_enrolment(user)
 
378
            if enrolment or user.admin:
 
379
                perms.add('view')
 
380
            if (enrolment and enrolment.role in (u'tutor', u'lecturer')) \
 
381
               or user.admin:
 
382
                perms.add('edit')
 
383
                # XXX Bug #493945 -- should tutors have these permissions?
 
384
                # Potentially move into the next category (lecturer & admin)
 
385
                perms.add('enrol')          # Can see enrolment screen at all
 
386
                perms.add('enrol_student')  # Can enrol students
 
387
            if (enrolment and enrolment.role in (u'lecturer')) or user.admin:
 
388
                perms.add('enrol_tutor')    # Can enrol tutors
 
389
            if user.admin:
 
390
                perms.add('enrol_lecturer') # Can enrol lecturers
 
391
        return perms
 
392
 
 
393
    def get_enrolment(self, user):
 
394
        """Find the user's enrolment in this offering."""
 
395
        try:
 
396
            enrolment = self.enrolments.find(user=user).one()
 
397
        except NotOneError:
 
398
            enrolment = None
 
399
 
 
400
        return enrolment
 
401
 
 
402
    def get_members_by_role(self, role):
 
403
        return Store.of(self).find(User,
 
404
                Enrolment.user_id == User.id,
 
405
                Enrolment.offering_id == self.id,
 
406
                Enrolment.role == role
 
407
                ).order_by(User.login)
 
408
 
 
409
    @property
 
410
    def students(self):
 
411
        return self.get_members_by_role(u'student')
 
412
 
 
413
    def get_open_projects_for_user(self, user):
 
414
        """Find all projects currently open to submissions by a user."""
 
415
        # XXX: Respect extensions.
 
416
        return self.projects.find(Project.deadline > datetime.datetime.now())
 
417
 
213
418
class Enrolment(Storm):
 
419
    """An enrolment of a user in an offering.
 
420
 
 
421
    This represents the roles of both staff and students.
 
422
    """
 
423
 
214
424
    __storm_table__ = "enrolment"
215
425
    __storm_primary__ = "user_id", "offering_id"
216
426
 
218
428
    user = Reference(user_id, User.id)
219
429
    offering_id = Int(name="offeringid")
220
430
    offering = Reference(offering_id, Offering.id)
221
 
    notes = Unicode()
222
 
    active = Bool()
223
 
 
224
 
    __init__ = _kwarg_init
225
 
 
226
 
    def __repr__(self):
227
 
        return "<%s %r in %r>" % (type(self).__name__, self.user,
228
 
                                  self.offering)
 
431
    role = Unicode()
 
432
    notes = Unicode()
 
433
    active = Bool()
 
434
 
 
435
    @property
 
436
    def groups(self):
 
437
        return Store.of(self).find(ProjectGroup,
 
438
                ProjectSet.offering_id == self.offering.id,
 
439
                ProjectGroup.project_set_id == ProjectSet.id,
 
440
                ProjectGroupMembership.project_group_id == ProjectGroup.id,
 
441
                ProjectGroupMembership.user_id == self.user.id)
 
442
 
 
443
    __init__ = _kwarg_init
 
444
 
 
445
    def __repr__(self):
 
446
        return "<%s %r in %r>" % (type(self).__name__, self.user,
 
447
                                  self.offering)
 
448
 
 
449
# PROJECTS #
 
450
 
 
451
class ProjectSet(Storm):
 
452
    """A set of projects that share common groups.
 
453
 
 
454
    Each student project group is attached to a project set. The group is
 
455
    valid for all projects in the group's set.
 
456
    """
 
457
 
 
458
    __storm_table__ = "project_set"
 
459
 
 
460
    id = Int(name="projectsetid", primary=True)
 
461
    offering_id = Int(name="offeringid")
 
462
    offering = Reference(offering_id, Offering.id)
 
463
    max_students_per_group = Int()
 
464
 
 
465
    projects = ReferenceSet(id, 'Project.project_set_id')
 
466
    project_groups = ReferenceSet(id, 'ProjectGroup.project_set_id')
 
467
 
 
468
    __init__ = _kwarg_init
 
469
 
 
470
    def __repr__(self):
 
471
        return "<%s %d in %r>" % (type(self).__name__, self.id,
 
472
                                  self.offering)
 
473
 
 
474
    def get_permissions(self, user):
 
475
        return self.offering.get_permissions(user)
 
476
 
 
477
    def get_groups_for_user(self, user):
 
478
        """List all groups in this offering of which the user is a member."""
 
479
        assert self.is_group
 
480
        return Store.of(self).find(
 
481
            ProjectGroup,
 
482
            ProjectGroupMembership.user_id == user.id,
 
483
            ProjectGroupMembership.project_group_id == ProjectGroup.id,
 
484
            ProjectGroup.project_set_id == self.id)
 
485
 
 
486
    def get_submission_principal(self, user):
 
487
        """Get the principal on behalf of which the user can submit.
 
488
 
 
489
        If this is a solo project set, the given user is returned. If
 
490
        the user is a member of exactly one group, all the group is
 
491
        returned. Otherwise, None is returned.
 
492
        """
 
493
        if self.is_group:
 
494
            groups = self.get_groups_for_user(user)
 
495
            if groups.count() == 1:
 
496
                return groups.one()
 
497
            else:
 
498
                return None
 
499
        else:
 
500
            return user
 
501
 
 
502
    @property
 
503
    def is_group(self):
 
504
        return self.max_students_per_group is not None
 
505
 
 
506
    @property
 
507
    def assigned(self):
 
508
        """Get the entities (groups or users) assigned to submit this project.
 
509
 
 
510
        This will be a Storm ResultSet.
 
511
        """
 
512
        #If its a solo project, return everyone in offering
 
513
        if self.is_group:
 
514
            return self.project_groups
 
515
        else:
 
516
            return self.offering.students
 
517
 
 
518
class Project(Storm):
 
519
    """A student project for which submissions can be made."""
 
520
 
 
521
    __storm_table__ = "project"
 
522
 
 
523
    id = Int(name="projectid", primary=True)
 
524
    name = Unicode()
 
525
    short_name = Unicode()
 
526
    synopsis = Unicode()
 
527
    url = Unicode()
 
528
    project_set_id = Int(name="projectsetid")
 
529
    project_set = Reference(project_set_id, ProjectSet.id)
 
530
    deadline = DateTime()
 
531
 
 
532
    assesseds = ReferenceSet(id, 'Assessed.project_id')
 
533
    submissions = ReferenceSet(id,
 
534
                               'Assessed.project_id',
 
535
                               'Assessed.id',
 
536
                               'ProjectSubmission.assessed_id')
 
537
 
 
538
    __init__ = _kwarg_init
 
539
 
 
540
    def __repr__(self):
 
541
        return "<%s '%s' in %r>" % (type(self).__name__, self.short_name,
 
542
                                  self.project_set.offering)
 
543
 
 
544
    def can_submit(self, principal):
 
545
        return (self in principal.get_projects() and
 
546
                self.deadline > datetime.datetime.now())
 
547
 
 
548
    def submit(self, principal, path, revision, who):
 
549
        """Submit a Subversion path and revision to a project.
 
550
 
 
551
        @param principal: The owner of the Subversion repository, and the
 
552
                          entity on behalf of whom the submission is being made
 
553
        @param path: A path within that repository to submit.
 
554
        @param revision: The revision of that path to submit.
 
555
        @param who: The user who is actually making the submission.
 
556
        """
 
557
 
 
558
        if not self.can_submit(principal):
 
559
            raise Exception('cannot submit')
 
560
 
 
561
        a = Assessed.get(Store.of(self), principal, self)
 
562
        ps = ProjectSubmission()
 
563
        ps.path = path
 
564
        ps.revision = revision
 
565
        ps.date_submitted = datetime.datetime.now()
 
566
        ps.assessed = a
 
567
        ps.submitter = who
 
568
 
 
569
        return ps
 
570
 
 
571
    def get_permissions(self, user):
 
572
        return self.project_set.offering.get_permissions(user)
 
573
 
 
574
    @property
 
575
    def latest_submissions(self):
 
576
        """Return the latest submission for each Assessed."""
 
577
        return Store.of(self).find(ProjectSubmission,
 
578
            Assessed.project_id == self.id,
 
579
            ProjectSubmission.assessed_id == Assessed.id,
 
580
            ProjectSubmission.date_submitted == Select(
 
581
                    Max(ProjectSubmission.date_submitted),
 
582
                    ProjectSubmission.assessed_id == Assessed.id,
 
583
                    tables=ProjectSubmission
 
584
            )
 
585
        )
 
586
 
 
587
    def has_deadline_passed(self, user):
 
588
        """Check whether the deadline has passed."""
 
589
        # XXX: Need to respect extensions.
 
590
        return self.deadline < datetime.datetime.now()
 
591
 
 
592
    def get_submissions_for_principal(self, principal):
 
593
        """Fetch a ResultSet of all submissions by a particular principal."""
 
594
        assessed = Assessed.get(Store.of(self), principal, self)
 
595
        if assessed is None:
 
596
            return
 
597
        return assessed.submissions
 
598
 
 
599
 
 
600
 
 
601
class ProjectGroup(Storm):
 
602
    """A group of students working together on a project."""
 
603
 
 
604
    __storm_table__ = "project_group"
 
605
 
 
606
    id = Int(name="groupid", primary=True)
 
607
    name = Unicode(name="groupnm")
 
608
    project_set_id = Int(name="projectsetid")
 
609
    project_set = Reference(project_set_id, ProjectSet.id)
 
610
    nick = Unicode()
 
611
    created_by_id = Int(name="createdby")
 
612
    created_by = Reference(created_by_id, User.id)
 
613
    epoch = DateTime()
 
614
 
 
615
    members = ReferenceSet(id,
 
616
                           "ProjectGroupMembership.project_group_id",
 
617
                           "ProjectGroupMembership.user_id",
 
618
                           "User.id")
 
619
 
 
620
    __init__ = _kwarg_init
 
621
 
 
622
    def __repr__(self):
 
623
        return "<%s %s in %r>" % (type(self).__name__, self.name,
 
624
                                  self.project_set.offering)
 
625
 
 
626
    @property
 
627
    def display_name(self):
 
628
        """Returns the "nice name" of the user or group."""
 
629
        return self.nick
 
630
 
 
631
    @property
 
632
    def short_name(self):
 
633
        """Returns the database "identifier" name of the user or group."""
 
634
        return self.name
 
635
 
 
636
    def get_projects(self, offering=None, active_only=True):
 
637
        '''Find projects that the group can submit.
 
638
 
 
639
        This will include projects in the project set which owns this group,
 
640
        unless the project set disallows groups (in which case none will be
 
641
        returned).
 
642
 
 
643
        @param active_only: Whether to only search active offerings.
 
644
        @param offering: An optional offering to restrict the search to.
 
645
        '''
 
646
        return Store.of(self).find(Project,
 
647
            Project.project_set_id == ProjectSet.id,
 
648
            ProjectSet.id == self.project_set.id,
 
649
            ProjectSet.max_students_per_group != None,
 
650
            ProjectSet.offering_id == Offering.id,
 
651
            (offering is None) or (Offering.id == offering.id),
 
652
            Semester.id == Offering.semester_id,
 
653
            (not active_only) or (Semester.state == u'current'))
 
654
 
 
655
 
 
656
    def get_permissions(self, user):
 
657
        if user.admin or user in self.members:
 
658
            return set(['submit_project'])
 
659
        else:
 
660
            return set()
 
661
 
 
662
class ProjectGroupMembership(Storm):
 
663
    """A student's membership in a project group."""
 
664
 
 
665
    __storm_table__ = "group_member"
 
666
    __storm_primary__ = "user_id", "project_group_id"
 
667
 
 
668
    user_id = Int(name="loginid")
 
669
    user = Reference(user_id, User.id)
 
670
    project_group_id = Int(name="groupid")
 
671
    project_group = Reference(project_group_id, ProjectGroup.id)
 
672
 
 
673
    __init__ = _kwarg_init
 
674
 
 
675
    def __repr__(self):
 
676
        return "<%s %r in %r>" % (type(self).__name__, self.user,
 
677
                                  self.project_group)
 
678
 
 
679
class Assessed(Storm):
 
680
    """A composite of a user or group combined with a project.
 
681
 
 
682
    Each project submission and extension refers to an Assessed. It is the
 
683
    sole specifier of the repository and project.
 
684
    """
 
685
 
 
686
    __storm_table__ = "assessed"
 
687
 
 
688
    id = Int(name="assessedid", primary=True)
 
689
    user_id = Int(name="loginid")
 
690
    user = Reference(user_id, User.id)
 
691
    project_group_id = Int(name="groupid")
 
692
    project_group = Reference(project_group_id, ProjectGroup.id)
 
693
 
 
694
    project_id = Int(name="projectid")
 
695
    project = Reference(project_id, Project.id)
 
696
 
 
697
    extensions = ReferenceSet(id, 'ProjectExtension.assessed_id')
 
698
    submissions = ReferenceSet(
 
699
        id, 'ProjectSubmission.assessed_id', order_by='date_submitted')
 
700
 
 
701
    def __repr__(self):
 
702
        return "<%s %r in %r>" % (type(self).__name__,
 
703
            self.user or self.project_group, self.project)
 
704
 
 
705
    @property
 
706
    def is_group(self):
 
707
        """True if the Assessed is a group, False if it is a user."""
 
708
        return self.project_group is not None
 
709
 
 
710
    @property
 
711
    def principal(self):
 
712
        return self.project_group or self.user
 
713
 
 
714
    @classmethod
 
715
    def get(cls, store, principal, project):
 
716
        """Find or create an Assessed for the given user or group and project.
 
717
 
 
718
        @param principal: The user or group.
 
719
        @param project: The project.
 
720
        """
 
721
        t = type(principal)
 
722
        if t not in (User, ProjectGroup):
 
723
            raise AssertionError('principal must be User or ProjectGroup')
 
724
 
 
725
        a = store.find(cls,
 
726
            (t is User) or (cls.project_group_id == principal.id),
 
727
            (t is ProjectGroup) or (cls.user_id == principal.id),
 
728
            cls.project_id == project.id).one()
 
729
 
 
730
        if a is None:
 
731
            a = cls()
 
732
            if t is User:
 
733
                a.user = principal
 
734
            else:
 
735
                a.project_group = principal
 
736
            a.project = project
 
737
            store.add(a)
 
738
 
 
739
        return a
 
740
 
 
741
 
 
742
class ProjectExtension(Storm):
 
743
    """An extension granted to a user or group on a particular project.
 
744
 
 
745
    The user or group and project are specified by the Assessed.
 
746
    """
 
747
 
 
748
    __storm_table__ = "project_extension"
 
749
 
 
750
    id = Int(name="extensionid", primary=True)
 
751
    assessed_id = Int(name="assessedid")
 
752
    assessed = Reference(assessed_id, Assessed.id)
 
753
    deadline = DateTime()
 
754
    approver_id = Int(name="approver")
 
755
    approver = Reference(approver_id, User.id)
 
756
    notes = Unicode()
 
757
 
 
758
class ProjectSubmission(Storm):
 
759
    """A submission from a user or group repository to a particular project.
 
760
 
 
761
    The content of a submission is a single path and revision inside a
 
762
    repository. The repository is that owned by the submission's user and
 
763
    group, while the path and revision are explicit.
 
764
 
 
765
    The user or group and project are specified by the Assessed.
 
766
    """
 
767
 
 
768
    __storm_table__ = "project_submission"
 
769
 
 
770
    id = Int(name="submissionid", primary=True)
 
771
    assessed_id = Int(name="assessedid")
 
772
    assessed = Reference(assessed_id, Assessed.id)
 
773
    path = Unicode()
 
774
    revision = Int()
 
775
    submitter_id = Int(name="submitter")
 
776
    submitter = Reference(submitter_id, User.id)
 
777
    date_submitted = DateTime()
 
778
 
 
779
 
 
780
# WORKSHEETS AND EXERCISES #
 
781
 
 
782
class Exercise(Storm):
 
783
    """An exercise for students to complete in a worksheet.
 
784
 
 
785
    An exercise may be present in any number of worksheets.
 
786
    """
 
787
 
 
788
    __storm_table__ = "exercise"
 
789
    id = Unicode(primary=True, name="identifier")
 
790
    name = Unicode()
 
791
    description = Unicode()
 
792
    partial = Unicode()
 
793
    solution = Unicode()
 
794
    include = Unicode()
 
795
    num_rows = Int()
 
796
 
 
797
    worksheet_exercises =  ReferenceSet(id,
 
798
        'WorksheetExercise.exercise_id')
 
799
 
 
800
    worksheets = ReferenceSet(id,
 
801
        'WorksheetExercise.exercise_id',
 
802
        'WorksheetExercise.worksheet_id',
 
803
        'Worksheet.id'
 
804
    )
 
805
 
 
806
    test_suites = ReferenceSet(id, 
 
807
        'TestSuite.exercise_id',
 
808
        order_by='seq_no')
 
809
 
 
810
    __init__ = _kwarg_init
 
811
 
 
812
    def __repr__(self):
 
813
        return "<%s %s>" % (type(self).__name__, self.name)
 
814
 
 
815
    def get_permissions(self, user):
 
816
        perms = set()
 
817
        roles = set()
 
818
        if user is not None:
 
819
            if user.admin:
 
820
                perms.add('edit')
 
821
                perms.add('view')
 
822
            elif u'lecturer' in set((e.role for e in user.active_enrolments)):
 
823
                perms.add('edit')
 
824
                perms.add('view')
 
825
            elif u'tutor' in set((e.role for e in user.active_enrolments)):
 
826
                perms.add('edit')
 
827
                perms.add('view')
 
828
 
 
829
        return perms
 
830
 
 
831
    def get_description(self):
 
832
        """Return the description interpreted as reStructuredText."""
 
833
        return rst(self.description)
 
834
 
 
835
    def delete(self):
 
836
        """Deletes the exercise, providing it has no associated worksheets."""
 
837
        if (self.worksheet_exercises.count() > 0):
 
838
            raise IntegrityError()
 
839
        for suite in self.test_suites:
 
840
            suite.delete()
 
841
        Store.of(self).remove(self)
 
842
 
 
843
class Worksheet(Storm):
 
844
    """A worksheet with exercises for students to complete.
 
845
 
 
846
    Worksheets are owned by offerings.
 
847
    """
 
848
 
 
849
    __storm_table__ = "worksheet"
 
850
 
 
851
    id = Int(primary=True, name="worksheetid")
 
852
    offering_id = Int(name="offeringid")
 
853
    identifier = Unicode()
 
854
    name = Unicode()
 
855
    assessable = Bool()
 
856
    data = Unicode()
 
857
    seq_no = Int()
 
858
    format = Unicode()
 
859
 
 
860
    attempts = ReferenceSet(id, "ExerciseAttempt.worksheetid")
 
861
    offering = Reference(offering_id, 'Offering.id')
 
862
 
 
863
    all_worksheet_exercises = ReferenceSet(id,
 
864
        'WorksheetExercise.worksheet_id')
 
865
 
 
866
    # Use worksheet_exercises to get access to the *active* WorksheetExercise
 
867
    # objects binding worksheets to exercises. This is required to access the
 
868
    # "optional" field.
 
869
 
 
870
    @property
 
871
    def worksheet_exercises(self):
 
872
        return self.all_worksheet_exercises.find(active=True)
 
873
 
 
874
    __init__ = _kwarg_init
 
875
 
 
876
    def __repr__(self):
 
877
        return "<%s %s>" % (type(self).__name__, self.name)
 
878
 
 
879
    def remove_all_exercises(self):
 
880
        """Remove all exercises from this worksheet.
 
881
 
 
882
        This does not delete the exercises themselves. It just removes them
 
883
        from the worksheet.
 
884
        """
 
885
        store = Store.of(self)
 
886
        for ws_ex in self.all_worksheet_exercises:
 
887
            if ws_ex.saves.count() > 0 or ws_ex.attempts.count() > 0:
 
888
                raise IntegrityError()
 
889
        store.find(WorksheetExercise,
 
890
            WorksheetExercise.worksheet == self).remove()
 
891
 
 
892
    def get_permissions(self, user):
 
893
        return self.offering.get_permissions(user)
 
894
 
 
895
    def get_xml(self):
 
896
        """Returns the xml of this worksheet, converts from rst if required."""
 
897
        if self.format == u'rst':
 
898
            ws_xml = rst(self.data)
 
899
            return ws_xml
 
900
        else:
 
901
            return self.data
 
902
 
 
903
    def delete(self):
 
904
        """Deletes the worksheet, provided it has no attempts on any exercises.
 
905
 
 
906
        Returns True if delete succeeded, or False if this worksheet has
 
907
        attempts attached."""
 
908
        for ws_ex in self.all_worksheet_exercises:
 
909
            if ws_ex.saves.count() > 0 or ws_ex.attempts.count() > 0:
 
910
                raise IntegrityError()
 
911
 
 
912
        self.remove_all_exercises()
 
913
        Store.of(self).remove(self)
 
914
 
 
915
class WorksheetExercise(Storm):
 
916
    """A link between a worksheet and one of its exercises.
 
917
 
 
918
    These may be marked optional, in which case the exercise does not count
 
919
    for marking purposes. The sequence number is used to order the worksheet
 
920
    ToC.
 
921
    """
 
922
 
 
923
    __storm_table__ = "worksheet_exercise"
 
924
 
 
925
    id = Int(primary=True, name="ws_ex_id")
 
926
 
 
927
    worksheet_id = Int(name="worksheetid")
 
928
    worksheet = Reference(worksheet_id, Worksheet.id)
 
929
    exercise_id = Unicode(name="exerciseid")
 
930
    exercise = Reference(exercise_id, Exercise.id)
 
931
    optional = Bool()
 
932
    active = Bool()
 
933
    seq_no = Int()
 
934
 
 
935
    saves = ReferenceSet(id, "ExerciseSave.ws_ex_id")
 
936
    attempts = ReferenceSet(id, "ExerciseAttempt.ws_ex_id")
 
937
 
 
938
    __init__ = _kwarg_init
 
939
 
 
940
    def __repr__(self):
 
941
        return "<%s %s in %s>" % (type(self).__name__, self.exercise.name,
 
942
                                  self.worksheet.identifier)
 
943
 
 
944
    def get_permissions(self, user):
 
945
        return self.worksheet.get_permissions(user)
 
946
 
 
947
 
 
948
class ExerciseSave(Storm):
 
949
    """A potential exercise solution submitted by a user for storage.
 
950
 
 
951
    This is not an actual tested attempt at an exercise, it's just a save of
 
952
    the editing session.
 
953
    """
 
954
 
 
955
    __storm_table__ = "exercise_save"
 
956
    __storm_primary__ = "ws_ex_id", "user_id"
 
957
 
 
958
    ws_ex_id = Int(name="ws_ex_id")
 
959
    worksheet_exercise = Reference(ws_ex_id, "WorksheetExercise.id")
 
960
 
 
961
    user_id = Int(name="loginid")
 
962
    user = Reference(user_id, User.id)
 
963
    date = DateTime()
 
964
    text = Unicode()
 
965
 
 
966
    __init__ = _kwarg_init
 
967
 
 
968
    def __repr__(self):
 
969
        return "<%s %s by %s at %s>" % (type(self).__name__,
 
970
            self.exercise.name, self.user.login, self.date.strftime("%c"))
 
971
 
 
972
class ExerciseAttempt(ExerciseSave):
 
973
    """An attempt at solving an exercise.
 
974
 
 
975
    This is a special case of ExerciseSave, used when the user submits a
 
976
    candidate solution. Like an ExerciseSave, it constitutes exercise solution
 
977
    data.
 
978
 
 
979
    In addition, it contains information about the result of the submission:
 
980
 
 
981
     - complete - True if this submission was successful, rendering this
 
982
                  exercise complete for this user in this worksheet.
 
983
     - active   - True if this submission is "active" (usually true).
 
984
                  Submissions may be de-activated by privileged users for
 
985
                  special reasons, and then they won't count (either as a
 
986
                  penalty or success), but will still be stored.
 
987
    """
 
988
 
 
989
    __storm_table__ = "exercise_attempt"
 
990
    __storm_primary__ = "ws_ex_id", "user_id", "date"
 
991
 
 
992
    # The "text" field is the same but has a different name in the DB table
 
993
    # for some reason.
 
994
    text = Unicode(name="attempt")
 
995
    complete = Bool()
 
996
    active = Bool()
 
997
 
 
998
    def get_permissions(self, user):
 
999
        return set(['view']) if user is self.user else set()
 
1000
 
 
1001
class TestSuite(Storm):
 
1002
    """A container to group an exercise's test cases.
 
1003
 
 
1004
    The test suite contains some information on how to test. The function to
 
1005
    test, variables to set and stdin data are stored here.
 
1006
    """
 
1007
 
 
1008
    __storm_table__ = "test_suite"
 
1009
    __storm_primary__ = "exercise_id", "suiteid"
 
1010
 
 
1011
    suiteid = Int()
 
1012
    exercise_id = Unicode(name="exerciseid")
 
1013
    description = Unicode()
 
1014
    seq_no = Int()
 
1015
    function = Unicode()
 
1016
    stdin = Unicode()
 
1017
    exercise = Reference(exercise_id, Exercise.id)
 
1018
    test_cases = ReferenceSet(suiteid, 'TestCase.suiteid', order_by="seq_no")
 
1019
    variables = ReferenceSet(suiteid, 'TestSuiteVar.suiteid', order_by='arg_no')
 
1020
 
 
1021
    def delete(self):
 
1022
        """Delete this suite, without asking questions."""
 
1023
        for variable in self.variables:
 
1024
            variable.delete()
 
1025
        for test_case in self.test_cases:
 
1026
            test_case.delete()
 
1027
        Store.of(self).remove(self)
 
1028
 
 
1029
class TestCase(Storm):
 
1030
    """A container for actual tests (see TestCasePart), inside a test suite.
 
1031
 
 
1032
    It is the lowest level shown to students on their pass/fail status."""
 
1033
 
 
1034
    __storm_table__ = "test_case"
 
1035
    __storm_primary__ = "testid", "suiteid"
 
1036
 
 
1037
    testid = Int()
 
1038
    suiteid = Int()
 
1039
    suite = Reference(suiteid, "TestSuite.suiteid")
 
1040
    passmsg = Unicode()
 
1041
    failmsg = Unicode()
 
1042
    test_default = Unicode() # Currently unused - only used for file matching.
 
1043
    seq_no = Int()
 
1044
 
 
1045
    parts = ReferenceSet(testid, "TestCasePart.testid")
 
1046
 
 
1047
    __init__ = _kwarg_init
 
1048
 
 
1049
    def delete(self):
 
1050
        for part in self.parts:
 
1051
            part.delete()
 
1052
        Store.of(self).remove(self)
 
1053
 
 
1054
class TestSuiteVar(Storm):
 
1055
    """A variable used by an exercise test suite.
 
1056
 
 
1057
    This may represent a function argument or a normal variable.
 
1058
    """
 
1059
 
 
1060
    __storm_table__ = "suite_variable"
 
1061
    __storm_primary__ = "varid"
 
1062
 
 
1063
    varid = Int()
 
1064
    suiteid = Int()
 
1065
    var_name = Unicode()
 
1066
    var_value = Unicode()
 
1067
    var_type = Unicode()
 
1068
    arg_no = Int()
 
1069
 
 
1070
    suite = Reference(suiteid, "TestSuite.suiteid")
 
1071
 
 
1072
    __init__ = _kwarg_init
 
1073
 
 
1074
    def delete(self):
 
1075
        Store.of(self).remove(self)
 
1076
 
 
1077
class TestCasePart(Storm):
 
1078
    """An actual piece of code to test an exercise solution."""
 
1079
 
 
1080
    __storm_table__ = "test_case_part"
 
1081
    __storm_primary__ = "partid"
 
1082
 
 
1083
    partid = Int()
 
1084
    testid = Int()
 
1085
 
 
1086
    part_type = Unicode()
 
1087
    test_type = Unicode()
 
1088
    data = Unicode()
 
1089
    filename = Unicode()
 
1090
 
 
1091
    test = Reference(testid, "TestCase.testid")
 
1092
 
 
1093
    __init__ = _kwarg_init
 
1094
 
 
1095
    def delete(self):
 
1096
        Store.of(self).remove(self)