← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ivle/database.py

ivle.studpath.url_to_jailpaths: Fix the doctest to use new paths.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/database.py
28
28
import datetime
29
29
 
30
30
from storm.locals import create_database, Store, Int, Unicode, DateTime, \
31
 
                         Reference
 
31
                         Reference, ReferenceSet, Bool, Storm, Desc
32
32
 
33
33
import ivle.conf
34
34
import ivle.caps
35
35
 
 
36
__all__ = ['get_store',
 
37
            'User',
 
38
            'Subject', 'Semester', 'Offering', 'Enrolment',
 
39
            'ProjectSet', 'Project', 'ProjectGroup', 'ProjectGroupMembership',
 
40
            'Exercise', 'Worksheet', 'WorksheetExercise',
 
41
            'ExerciseSave', 'ExerciseAttempt',
 
42
            'AlreadyEnrolledError'
 
43
        ]
 
44
 
 
45
def _kwarg_init(self, **kwargs):
 
46
    for k,v in kwargs.items():
 
47
        if k.startswith('_') or not hasattr(self.__class__, k):
 
48
            raise TypeError("%s got an unexpected keyword argument '%s'"
 
49
                % (self.__class__.__name__, k))
 
50
        setattr(self, k, v)
 
51
 
36
52
def get_conn_string():
37
53
    """
38
54
    Returns the Storm connection string, generated from the conf file.
48
64
    """
49
65
    return Store(create_database(get_conn_string()))
50
66
 
51
 
class User(object):
 
67
# USERS #
 
68
 
 
69
class User(Storm):
52
70
    """
53
71
    Represents an IVLE user.
54
72
    """
80
98
        self.rolenm = unicode(value)
81
99
    role = property(_get_role, _set_role)
82
100
 
83
 
    def __init__(self, **kwargs):
84
 
        """
85
 
        Create a new User object. Supply any columns as a keyword argument.
86
 
        """
87
 
        for k,v in kwargs.items():
88
 
            if k.startswith('_') or not hasattr(self, k):
89
 
                raise TypeError("User got an unexpected keyword argument '%s'"
90
 
                    % k)
91
 
            setattr(self, k, v)
 
101
    __init__ = _kwarg_init
92
102
 
93
103
    def __repr__(self):
94
104
        return "<%s '%s'>" % (type(self).__name__, self.login)
120
130
        fieldval = self.acct_exp
121
131
        return fieldval is not None and datetime.datetime.now() > fieldval
122
132
 
 
133
    def _get_enrolments(self, justactive):
 
134
        return Store.of(self).find(Enrolment,
 
135
            Enrolment.user_id == self.id,
 
136
            (Enrolment.active == True) if justactive else True,
 
137
            Enrolment.offering_id == Offering.id,
 
138
            Offering.semester_id == Semester.id,
 
139
            Offering.subject_id == Subject.id).order_by(
 
140
                Desc(Semester.year),
 
141
                Desc(Semester.semester),
 
142
                Desc(Subject.code)
 
143
            )
 
144
 
 
145
    def _set_password(self, password):
 
146
        if password is None:
 
147
            self.passhash = None
 
148
        else:
 
149
            self.passhash = unicode(User.hash_password(password))
 
150
    password = property(fset=_set_password)
 
151
 
 
152
    @property
 
153
    def subjects(self):
 
154
        return Store.of(self).find(Subject,
 
155
            Enrolment.user_id == self.id,
 
156
            Enrolment.active == True,
 
157
            Offering.id == Enrolment.offering_id,
 
158
            Subject.id == Offering.subject_id).config(distinct=True)
 
159
 
 
160
    # TODO: Invitations should be listed too?
 
161
    def get_groups(self, offering=None):
 
162
        preds = [
 
163
            ProjectGroupMembership.user_id == self.id,
 
164
            ProjectGroup.id == ProjectGroupMembership.project_group_id,
 
165
        ]
 
166
        if offering:
 
167
            preds.extend([
 
168
                ProjectSet.offering_id == offering.id,
 
169
                ProjectGroup.project_set_id == ProjectSet.id,
 
170
            ])
 
171
        return Store.of(self).find(ProjectGroup, *preds)
 
172
 
 
173
    @property
 
174
    def groups(self):
 
175
        return self.get_groups()
 
176
 
 
177
    @property
 
178
    def active_enrolments(self):
 
179
        '''A sanely ordered list of the user's active enrolments.'''
 
180
        return self._get_enrolments(True)
 
181
 
 
182
    @property
 
183
    def enrolments(self):
 
184
        '''A sanely ordered list of all of the user's enrolments.'''
 
185
        return self._get_enrolments(False) 
 
186
 
123
187
    @staticmethod
124
188
    def hash_password(password):
125
189
        return md5.md5(password).hexdigest()
131
195
        login.
132
196
        """
133
197
        return store.find(cls, cls.login == unicode(login)).one()
 
198
 
 
199
# SUBJECTS AND ENROLMENTS #
 
200
 
 
201
class Subject(Storm):
 
202
    __storm_table__ = "subject"
 
203
 
 
204
    id = Int(primary=True, name="subjectid")
 
205
    code = Unicode(name="subj_code")
 
206
    name = Unicode(name="subj_name")
 
207
    short_name = Unicode(name="subj_short_name")
 
208
    url = Unicode()
 
209
 
 
210
    offerings = ReferenceSet(id, 'Offering.subject_id')
 
211
 
 
212
    __init__ = _kwarg_init
 
213
 
 
214
    def __repr__(self):
 
215
        return "<%s '%s'>" % (type(self).__name__, self.short_name)
 
216
 
 
217
class Semester(Storm):
 
218
    __storm_table__ = "semester"
 
219
 
 
220
    id = Int(primary=True, name="semesterid")
 
221
    year = Unicode()
 
222
    semester = Unicode()
 
223
    active = Bool()
 
224
 
 
225
    offerings = ReferenceSet(id, 'Offering.semester_id')
 
226
 
 
227
    __init__ = _kwarg_init
 
228
 
 
229
    def __repr__(self):
 
230
        return "<%s %s/%s>" % (type(self).__name__, self.year, self.semester)
 
231
 
 
232
class Offering(Storm):
 
233
    __storm_table__ = "offering"
 
234
 
 
235
    id = Int(primary=True, name="offeringid")
 
236
    subject_id = Int(name="subject")
 
237
    subject = Reference(subject_id, Subject.id)
 
238
    semester_id = Int(name="semesterid")
 
239
    semester = Reference(semester_id, Semester.id)
 
240
    groups_student_permissions = Unicode()
 
241
 
 
242
    enrolments = ReferenceSet(id, 'Enrolment.offering_id')
 
243
    members = ReferenceSet(id,
 
244
                           'Enrolment.offering_id',
 
245
                           'Enrolment.user_id',
 
246
                           'User.id')
 
247
    project_sets = ReferenceSet(id, 'ProjectSet.offering_id')
 
248
 
 
249
    __init__ = _kwarg_init
 
250
 
 
251
    def __repr__(self):
 
252
        return "<%s %r in %r>" % (type(self).__name__, self.subject,
 
253
                                  self.semester)
 
254
 
 
255
    def enrol(self, user):
 
256
        '''Enrol a user in this offering.'''
 
257
        # We'll get a horrible database constraint violation error if we try
 
258
        # to add a second enrolment.
 
259
        if Store.of(self).find(Enrolment,
 
260
                               Enrolment.user_id == user.id,
 
261
                               Enrolment.offering_id == self.id).count() == 1:
 
262
            raise AlreadyEnrolledError()
 
263
 
 
264
        e = Enrolment(user=user, offering=self, active=True)
 
265
        self.enrolments.add(e)
 
266
 
 
267
class Enrolment(Storm):
 
268
    __storm_table__ = "enrolment"
 
269
    __storm_primary__ = "user_id", "offering_id"
 
270
 
 
271
    user_id = Int(name="loginid")
 
272
    user = Reference(user_id, User.id)
 
273
    offering_id = Int(name="offeringid")
 
274
    offering = Reference(offering_id, Offering.id)
 
275
    notes = Unicode()
 
276
    active = Bool()
 
277
 
 
278
    @property
 
279
    def groups(self):
 
280
        return Store.of(self).find(ProjectGroup,
 
281
                ProjectSet.offering_id == self.offering.id,
 
282
                ProjectGroup.project_set_id == ProjectSet.id,
 
283
                ProjectGroupMembership.project_group_id == ProjectGroup.id,
 
284
                ProjectGroupMembership.user_id == self.user.id)
 
285
 
 
286
    __init__ = _kwarg_init
 
287
 
 
288
    def __repr__(self):
 
289
        return "<%s %r in %r>" % (type(self).__name__, self.user,
 
290
                                  self.offering)
 
291
 
 
292
class AlreadyEnrolledError(Exception):
 
293
    pass
 
294
 
 
295
# PROJECTS #
 
296
 
 
297
class ProjectSet(Storm):
 
298
    __storm_table__ = "project_set"
 
299
 
 
300
    id = Int(name="projectsetid", primary=True)
 
301
    offering_id = Int(name="offeringid")
 
302
    offering = Reference(offering_id, Offering.id)
 
303
    max_students_per_group = Int()
 
304
 
 
305
    projects = ReferenceSet(id, 'Project.project_set_id')
 
306
    project_groups = ReferenceSet(id, 'ProjectGroup.project_set_id')
 
307
 
 
308
    __init__ = _kwarg_init
 
309
 
 
310
    def __repr__(self):
 
311
        return "<%s %d in %r>" % (type(self).__name__, self.id,
 
312
                                  self.offering)
 
313
 
 
314
class Project(Storm):
 
315
    __storm_table__ = "project"
 
316
 
 
317
    id = Int(name="projectid", primary=True)
 
318
    synopsis = Unicode()
 
319
    url = Unicode()
 
320
    project_set_id = Int(name="projectsetid")
 
321
    project_set = Reference(project_set_id, ProjectSet.id)
 
322
    deadline = DateTime()
 
323
 
 
324
    __init__ = _kwarg_init
 
325
 
 
326
    def __repr__(self):
 
327
        return "<%s '%s' in %r>" % (type(self).__name__, self.synopsis,
 
328
                                  self.project_set.offering)
 
329
 
 
330
class ProjectGroup(Storm):
 
331
    __storm_table__ = "project_group"
 
332
 
 
333
    id = Int(name="groupid", primary=True)
 
334
    name = Unicode(name="groupnm")
 
335
    project_set_id = Int(name="projectsetid")
 
336
    project_set = Reference(project_set_id, ProjectSet.id)
 
337
    nick = Unicode()
 
338
    created_by_id = Int(name="createdby")
 
339
    created_by = Reference(created_by_id, User.id)
 
340
    epoch = DateTime()
 
341
 
 
342
    members = ReferenceSet(id,
 
343
                           "ProjectGroupMembership.project_group_id",
 
344
                           "ProjectGroupMembership.user_id",
 
345
                           "User.id")
 
346
 
 
347
    __init__ = _kwarg_init
 
348
 
 
349
    def __repr__(self):
 
350
        return "<%s %s in %r>" % (type(self).__name__, self.name,
 
351
                                  self.project_set.offering)
 
352
 
 
353
class ProjectGroupMembership(Storm):
 
354
    __storm_table__ = "group_member"
 
355
    __storm_primary__ = "user_id", "project_group_id"
 
356
 
 
357
    user_id = Int(name="loginid")
 
358
    user = Reference(user_id, User.id)
 
359
    project_group_id = Int(name="groupid")
 
360
    project_group = Reference(project_group_id, ProjectGroup.id)
 
361
 
 
362
    __init__ = _kwarg_init
 
363
 
 
364
    def __repr__(self):
 
365
        return "<%s %r in %r>" % (type(self).__name__, self.user,
 
366
                                  self.project_group)
 
367
 
 
368
# WORKSHEETS AND EXERCISES #
 
369
 
 
370
class Exercise(Storm):
 
371
    # Note: Table "problem" is called "Exercise" in the Object layer, since
 
372
    # it's called that everywhere else.
 
373
    __storm_table__ = "problem"
 
374
 
 
375
    id = Int(primary=True, name="problemid")
 
376
    name = Unicode(name="identifier")
 
377
    spec = Unicode()
 
378
 
 
379
    worksheets = ReferenceSet(id,
 
380
        'WorksheetExercise.exercise_id',
 
381
        'WorksheetExercise.worksheet_id',
 
382
        'Worksheet.id'
 
383
    )
 
384
 
 
385
    __init__ = _kwarg_init
 
386
 
 
387
    def __repr__(self):
 
388
        return "<%s %s>" % (type(self).__name__, self.name)
 
389
 
 
390
    @classmethod
 
391
    def get_by_name(cls, store, name):
 
392
        """
 
393
        Get the Exercise from the db associated with a given store and name.
 
394
        If the exercise is not in the database, creates it and inserts it
 
395
        automatically.
 
396
        """
 
397
        ex = store.find(cls, cls.name == unicode(name)).one()
 
398
        if ex is not None:
 
399
            return ex
 
400
        ex = Exercise(name=unicode(name))
 
401
        store.add(ex)
 
402
        store.commit()
 
403
        return ex
 
404
 
 
405
class Worksheet(Storm):
 
406
    __storm_table__ = "worksheet"
 
407
 
 
408
    id = Int(primary=True, name="worksheetid")
 
409
    # XXX subject is not linked to a Subject object. This is a property of
 
410
    # the database, and will be refactored.
 
411
    subject = Unicode()
 
412
    name = Unicode(name="identifier")
 
413
    assessable = Bool()
 
414
    mtime = DateTime()
 
415
 
 
416
    exercises = ReferenceSet(id,
 
417
        'WorksheetExercise.worksheet_id',
 
418
        'WorksheetExercise.exercise_id',
 
419
        Exercise.id)
 
420
    # Use worksheet_exercises to get access to the WorksheetExercise objects
 
421
    # binding worksheets to exercises. This is required to access the
 
422
    # "optional" field.
 
423
    worksheet_exercises = ReferenceSet(id,
 
424
        'WorksheetExercise.worksheet_id')
 
425
 
 
426
    __init__ = _kwarg_init
 
427
 
 
428
    def __repr__(self):
 
429
        return "<%s %s>" % (type(self).__name__, self.name)
 
430
 
 
431
    # XXX Refactor this - make it an instance method of Subject rather than a
 
432
    # class method of Worksheet. Can't do that now because Subject isn't
 
433
    # linked referentially to the Worksheet.
 
434
    @classmethod
 
435
    def get_by_name(cls, store, subjectname, worksheetname):
 
436
        """
 
437
        Get the Worksheet from the db associated with a given store, subject
 
438
        name and worksheet name.
 
439
        """
 
440
        return store.find(cls, cls.subject == unicode(subjectname),
 
441
            cls.name == unicode(worksheetname)).one()
 
442
 
 
443
    def remove_all_exercises(self, store):
 
444
        """
 
445
        Remove all exercises from this worksheet.
 
446
        This does not delete the exercises themselves. It just removes them
 
447
        from the worksheet.
 
448
        """
 
449
        store.find(WorksheetExercise,
 
450
            WorksheetExercise.worksheet == self).remove()
 
451
 
 
452
class WorksheetExercise(Storm):
 
453
    __storm_table__ = "worksheet_problem"
 
454
    __storm_primary__ = "worksheet_id", "exercise_id"
 
455
 
 
456
    worksheet_id = Int(name="worksheetid")
 
457
    worksheet = Reference(worksheet_id, Worksheet.id)
 
458
    exercise_id = Int(name="problemid")
 
459
    exercise = Reference(exercise_id, Exercise.id)
 
460
    optional = Bool()
 
461
 
 
462
    __init__ = _kwarg_init
 
463
 
 
464
    def __repr__(self):
 
465
        return "<%s %s in %s>" % (type(self).__name__, self.exercise.name,
 
466
                                  self.worksheet.name)
 
467
 
 
468
class ExerciseSave(Storm):
 
469
    """
 
470
    Represents a potential solution to an exercise that a user has submitted
 
471
    to the server for storage.
 
472
    A basic ExerciseSave is just the current saved text for this exercise for
 
473
    this user (doesn't count towards their attempts).
 
474
    ExerciseSave may be extended with additional semantics (such as
 
475
    ExerciseAttempt).
 
476
    """
 
477
    __storm_table__ = "problem_save"
 
478
    __storm_primary__ = "exercise_id", "user_id", "date"
 
479
 
 
480
    exercise_id = Int(name="problemid")
 
481
    exercise = Reference(exercise_id, Exercise.id)
 
482
    user_id = Int(name="loginid")
 
483
    user = Reference(user_id, User.id)
 
484
    date = DateTime()
 
485
    text = Unicode()
 
486
 
 
487
    __init__ = _kwarg_init
 
488
 
 
489
    def __repr__(self):
 
490
        return "<%s %s by %s at %s>" % (type(self).__name__,
 
491
            self.exercise.name, self.user.login, self.date.strftime("%c"))
 
492
 
 
493
class ExerciseAttempt(ExerciseSave):
 
494
    """
 
495
    An ExerciseAttempt is a special case of an ExerciseSave. Like an
 
496
    ExerciseSave, it constitutes exercise solution data that the user has
 
497
    submitted to the server for storage.
 
498
    In addition, it contains additional information about the submission.
 
499
    complete - True if this submission was successful, rendering this exercise
 
500
        complete for this user.
 
501
    active - True if this submission is "active" (usually true). Submissions
 
502
        may be de-activated by privileged users for special reasons, and then
 
503
        they won't count (either as a penalty or success), but will still be
 
504
        stored.
 
505
    """
 
506
    __storm_table__ = "problem_attempt"
 
507
    __storm_primary__ = "exercise_id", "user_id", "date"
 
508
 
 
509
    # The "text" field is the same but has a different name in the DB table
 
510
    # for some reason.
 
511
    text = Unicode(name="attempt")
 
512
    complete = Bool()
 
513
    active = Bool()