← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ivle/database.py

  • Committer: me at id
  • Date: 2009-01-15 05:53:45 UTC
  • mto: This revision was merged to the branch mainline in revision 1090.
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:branches%2Fstorm:1161
bin/ivle-showenrolment: Switch to ivle.database.User.enrolments from
    ivle.db.get_enrolment, removing the dependency on ivle.db.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/database.py
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
36
def _kwarg_init(self, **kwargs):
46
37
    for k,v in kwargs.items():
47
 
        if k.startswith('_') or not hasattr(self.__class__, k):
 
38
        if k.startswith('_') or not hasattr(self, k):
48
39
            raise TypeError("%s got an unexpected keyword argument '%s'"
49
 
                % (self.__class__.__name__, k))
 
40
                % self.__class__.__name__, k)
50
41
        setattr(self, k, v)
51
42
 
52
43
def get_conn_string():
64
55
    """
65
56
    return Store(create_database(get_conn_string()))
66
57
 
67
 
# USERS #
68
 
 
69
58
class User(Storm):
70
59
    """
71
60
    Represents an IVLE user.
142
131
                Desc(Subject.code)
143
132
            )
144
133
 
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
134
    @property
178
135
    def active_enrolments(self):
179
136
        '''A sanely ordered list of the user's active enrolments.'''
196
153
        """
197
154
        return store.find(cls, cls.login == unicode(login)).one()
198
155
 
199
 
# SUBJECTS AND ENROLMENTS #
200
 
 
201
156
class Subject(Storm):
202
157
    __storm_table__ = "subject"
203
158
 
240
195
    groups_student_permissions = Unicode()
241
196
 
242
197
    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
198
 
249
199
    __init__ = _kwarg_init
250
200
 
252
202
        return "<%s %r in %r>" % (type(self).__name__, self.subject,
253
203
                                  self.semester)
254
204
 
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
205
class Enrolment(Storm):
268
206
    __storm_table__ = "enrolment"
269
207
    __storm_primary__ = "user_id", "offering_id"
275
213
    notes = Unicode()
276
214
    active = Bool()
277
215
 
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()
 
216
    __init__ = _kwarg_init
 
217
 
 
218
    def __repr__(self):
 
219
        return "<%s %r in %r>" % (type(self).__name__, self.user,
 
220
                                  self.offering)