← 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-17 08:37:22 UTC
  • Revision ID: grantw@unimelb.edu.au-20100217083722-ji4v6fbztngy0p3s
Add UI to edit/delete enrolments.

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