24
24
It also provides miscellaneous utility functions for database interaction.
30
30
from storm.locals import create_database, Store, Int, Unicode, DateTime, \
31
31
Reference, ReferenceSet, Bool, Storm, Desc
32
from storm.exceptions import NotOneError, IntegrityError
34
from ivle.worksheet.rst import rst
36
36
__all__ = ['get_store',
38
38
'Subject', 'Semester', 'Offering', 'Enrolment',
39
39
'ProjectSet', 'Project', 'ProjectGroup', 'ProjectGroupMembership',
40
'Assessed', 'ProjectSubmission', 'ProjectExtension',
41
40
'Exercise', 'Worksheet', 'WorksheetExercise',
42
41
'ExerciseSave', 'ExerciseAttempt',
43
'TestCase', 'TestSuite', 'TestSuiteVar'
42
'AlreadyEnrolledError', 'TestCase', 'TestSuite', 'TestSuiteVar'
46
45
def _kwarg_init(self, **kwargs):
50
49
% (self.__class__.__name__, k))
51
50
setattr(self, k, v)
53
def get_conn_string(config):
54
"""Create a Storm connection string to the IVLE database
56
@param config: The IVLE configuration.
60
if config['database']['username']:
61
clusterstr += config['database']['username']
62
if config['database']['password']:
63
clusterstr += ':' + config['database']['password']
66
host = config['database']['host'] or 'localhost'
67
port = config['database']['port'] or 5432
69
clusterstr += '%s:%d' % (host, port)
71
return "postgres://%s/%s" % (clusterstr, config['database']['name'])
73
def get_store(config):
74
"""Create a Storm store connected to the IVLE database.
76
@param config: The IVLE configuration.
78
return Store(create_database(get_conn_string(config)))
52
def get_conn_string():
54
Returns the Storm connection string, generated from the conf file.
56
return "postgres://%s:%s@%s:%d/%s" % (ivle.conf.db_user,
57
ivle.conf.db_password, ivle.conf.db_host, ivle.conf.db_port,
62
Open a database connection and transaction. Return a storm.store.Store
63
instance connected to the configured IVLE database.
65
return Store(create_database(get_conn_string()))
189
188
'''A sanely ordered list of all of the user's enrolments.'''
190
189
return self._get_enrolments(False)
192
def get_projects(self, offering=None, active_only=True):
193
'''Return Projects that the user can submit.
195
This will include projects for offerings in which the user is
196
enrolled, as long as the project is not in a project set which has
197
groups (ie. if maximum number of group members is 0).
199
Unless active_only is False, only projects for active offerings will
202
If an offering is specified, returned projects will be limited to
203
those for that offering.
205
return Store.of(self).find(Project,
206
Project.project_set_id == ProjectSet.id,
207
ProjectSet.max_students_per_group == None,
208
ProjectSet.offering_id == Offering.id,
209
(offering is None) or (Offering.id == offering.id),
210
Semester.id == Offering.semester_id,
211
(not active_only) or (Semester.state == u'current'),
212
Enrolment.offering_id == Offering.id,
213
Enrolment.user_id == self.id)
216
192
def hash_password(password):
217
return hashlib.md5(password).hexdigest()
193
return md5.md5(password).hexdigest()
220
196
def get_by_login(cls, store, login):
253
229
if user is not None:
254
230
perms.add('view')
231
if user.rolenm == 'admin':
256
232
perms.add('edit')
259
def active_offerings(self):
260
"""Return a sequence of currently active offerings for this subject
261
(offerings whose semester.state is "current"). There should be 0 or 1
262
elements in this sequence, but it's possible there are more.
264
return self.offerings.find(Offering.semester_id == Semester.id,
265
Semester.state == u'current')
267
def offering_for_semester(self, year, semester):
268
"""Get the offering for the given year/semester, or None."""
269
return self.offerings.find(Offering.semester_id == Semester.id,
270
Semester.year == unicode(year),
271
Semester.semester == unicode(semester)).one()
273
235
class Semester(Storm):
274
236
__storm_table__ = "semester"
276
238
id = Int(primary=True, name="semesterid")
278
240
semester = Unicode()
281
243
offerings = ReferenceSet(id, 'Offering.semester_id')
282
enrolments = ReferenceSet(id,
283
'Offering.semester_id',
285
'Enrolment.offering_id')
287
245
__init__ = _kwarg_init
317
272
return "<%s %r in %r>" % (type(self).__name__, self.subject,
320
def enrol(self, user, role=u'student'):
275
def enrol(self, user):
321
276
'''Enrol a user in this offering.'''
322
enrolment = Store.of(self).find(Enrolment,
323
Enrolment.user_id == user.id,
324
Enrolment.offering_id == self.id).one()
326
if enrolment is None:
327
enrolment = Enrolment(user=user, offering=self)
328
self.enrolments.add(enrolment)
330
enrolment.active = True
331
enrolment.role = role
333
def unenrol(self, user):
334
'''Unenrol a user from this offering.'''
335
enrolment = Store.of(self).find(Enrolment,
336
Enrolment.user_id == user.id,
337
Enrolment.offering_id == self.id).one()
338
Store.of(enrolment).remove(enrolment)
277
# We'll get a horrible database constraint violation error if we try
278
# to add a second enrolment.
279
if Store.of(self).find(Enrolment,
280
Enrolment.user_id == user.id,
281
Enrolment.offering_id == self.id).count() == 1:
282
raise AlreadyEnrolledError()
284
e = Enrolment(user=user, offering=self, active=True)
285
self.enrolments.add(e)
340
287
def get_permissions(self, user):
342
289
if user is not None:
343
enrolment = self.get_enrolment(user)
344
if enrolment or user.admin:
346
if (enrolment and enrolment.role in (u'tutor', u'lecturer')) \
291
if user.rolenm == 'admin':
348
292
perms.add('edit')
351
def get_enrolment(self, user):
353
enrolment = self.enrolments.find(user=user).one()
359
295
class Enrolment(Storm):
360
296
__storm_table__ = "enrolment"
361
297
__storm_primary__ = "user_id", "offering_id"
405
343
__storm_table__ = "project"
407
345
id = Int(name="projectid", primary=True)
409
short_name = Unicode()
410
346
synopsis = Unicode()
412
348
project_set_id = Int(name="projectsetid")
413
349
project_set = Reference(project_set_id, ProjectSet.id)
414
350
deadline = DateTime()
416
assesseds = ReferenceSet(id, 'Assessed.project_id')
417
submissions = ReferenceSet(id,
418
'Assessed.project_id',
420
'ProjectSubmission.assessed_id')
422
352
__init__ = _kwarg_init
424
354
def __repr__(self):
425
return "<%s '%s' in %r>" % (type(self).__name__, self.short_name,
355
return "<%s '%s' in %r>" % (type(self).__name__, self.synopsis,
426
356
self.project_set.offering)
428
def can_submit(self, principal):
429
return (self in principal.get_projects() and
430
self.deadline > datetime.datetime.now())
432
def submit(self, principal, path, revision, who):
433
"""Submit a Subversion path and revision to a project.
435
'principal' is the owner of the Subversion repository, and the
436
entity on behalf of whom the submission is being made. 'path' is
437
a path within that repository, and 'revision' specifies which
438
revision of that path. 'who' is the person making the submission.
441
if not self.can_submit(principal):
442
raise Exception('cannot submit')
444
a = Assessed.get(Store.of(self), principal, self)
445
ps = ProjectSubmission()
447
ps.revision = revision
448
ps.date_submitted = datetime.datetime.now()
455
358
class ProjectGroup(Storm):
456
359
__storm_table__ = "project_group"
475
378
return "<%s %s in %r>" % (type(self).__name__, self.name,
476
379
self.project_set.offering)
479
def display_name(self):
480
return '%s (%s)' % (self.nick, self.name)
482
def get_projects(self, offering=None, active_only=True):
483
'''Return Projects that the group can submit.
485
This will include projects in the project set which owns this group,
486
unless the project set disallows groups (in which case none will be
489
Unless active_only is False, projects will only be returned if the
490
group's offering is active.
492
If an offering is specified, projects will only be returned if it
495
return Store.of(self).find(Project,
496
Project.project_set_id == ProjectSet.id,
497
ProjectSet.id == self.project_set.id,
498
ProjectSet.max_students_per_group != None,
499
ProjectSet.offering_id == Offering.id,
500
(offering is None) or (Offering.id == offering.id),
501
Semester.id == Offering.semester_id,
502
(not active_only) or (Semester.state == u'current'))
505
def get_permissions(self, user):
506
if user.admin or user in self.members:
507
return set(['submit_project'])
511
381
class ProjectGroupMembership(Storm):
512
382
__storm_table__ = "group_member"
513
383
__storm_primary__ = "user_id", "project_group_id"
523
393
return "<%s %r in %r>" % (type(self).__name__, self.user,
524
394
self.project_group)
526
class Assessed(Storm):
527
__storm_table__ = "assessed"
529
id = Int(name="assessedid", primary=True)
530
user_id = Int(name="loginid")
531
user = Reference(user_id, User.id)
532
project_group_id = Int(name="groupid")
533
project_group = Reference(project_group_id, ProjectGroup.id)
535
project_id = Int(name="projectid")
536
project = Reference(project_id, Project.id)
538
extensions = ReferenceSet(id, 'ProjectExtension.assessed_id')
539
submissions = ReferenceSet(id, 'ProjectSubmission.assessed_id')
542
return "<%s %r in %r>" % (type(self).__name__,
543
self.user or self.project_group, self.project)
546
def get(cls, store, principal, project):
548
if t not in (User, ProjectGroup):
549
raise AssertionError('principal must be User or ProjectGroup')
552
(t is User) or (cls.project_group_id == principal.id),
553
(t is ProjectGroup) or (cls.user_id == principal.id),
554
Project.id == project.id).one()
561
a.project_group = principal
568
class ProjectExtension(Storm):
569
__storm_table__ = "project_extension"
571
id = Int(name="extensionid", primary=True)
572
assessed_id = Int(name="assessedid")
573
assessed = Reference(assessed_id, Assessed.id)
574
deadline = DateTime()
575
approver_id = Int(name="approver")
576
approver = Reference(approver_id, User.id)
579
class ProjectSubmission(Storm):
580
__storm_table__ = "project_submission"
582
id = Int(name="submissionid", primary=True)
583
assessed_id = Int(name="assessedid")
584
assessed = Reference(assessed_id, Assessed.id)
587
submitter_id = Int(name="submitter")
588
submitter = Reference(submitter_id, User.id)
589
date_submitted = DateTime()
592
396
# WORKSHEETS AND EXERCISES #
594
398
class Exercise(Storm):
595
__storm_table__ = "exercise"
399
# Note: Table "problem" is called "Exercise" in the Object layer, since
400
# it's called that everywhere else.
401
__storm_table__ = "problem"
402
#TODO: Add in a field for the user-friendly identifier
596
403
id = Unicode(primary=True, name="identifier")
598
405
description = Unicode()
601
408
include = Unicode()
604
worksheet_exercises = ReferenceSet(id,
605
'WorksheetExercise.exercise_id')
607
411
worksheets = ReferenceSet(id,
608
412
'WorksheetExercise.exercise_id',
609
413
'WorksheetExercise.worksheet_id',
613
test_suites = ReferenceSet(id,
614
'TestSuite.exercise_id',
417
test_suites = ReferenceSet(id, 'TestSuite.exercise_id')
617
419
__init__ = _kwarg_init
619
421
def __repr__(self):
620
422
return "<%s %s>" % (type(self).__name__, self.name)
622
def get_permissions(self, user):
629
elif 'lecturer' in set((e.role for e in user.active_enrolments)):
635
def get_description(self):
636
return rst(self.description)
639
"""Deletes the exercise, providing it has no associated worksheets."""
640
if (self.worksheet_exercises.count() > 0):
641
raise IntegrityError()
642
for suite in self.test_suites:
644
Store.of(self).remove(self)
646
425
class Worksheet(Storm):
647
426
__storm_table__ = "worksheet"
649
428
id = Int(primary=True, name="worksheetid")
429
# XXX subject is not linked to a Subject object. This is a property of
430
# the database, and will be refactored.
650
431
offering_id = Int(name="offeringid")
651
identifier = Unicode()
432
name = Unicode(name="identifier")
653
433
assessable = Bool()
658
436
attempts = ReferenceSet(id, "ExerciseAttempt.worksheetid")
659
437
offering = Reference(offering_id, 'Offering.id')
661
all_worksheet_exercises = ReferenceSet(id,
439
exercises = ReferenceSet(id,
440
'WorksheetExercise.worksheet_id',
441
'WorksheetExercise.exercise_id',
443
# Use worksheet_exercises to get access to the WorksheetExercise objects
444
# binding worksheets to exercises. This is required to access the
446
worksheet_exercises = ReferenceSet(id,
662
447
'WorksheetExercise.worksheet_id')
664
# Use worksheet_exercises to get access to the *active* WorksheetExercise
665
# objects binding worksheets to exercises. This is required to access the
669
def worksheet_exercises(self):
670
return self.all_worksheet_exercises.find(active=True)
672
450
__init__ = _kwarg_init
674
452
def __repr__(self):
675
453
return "<%s %s>" % (type(self).__name__, self.name)
677
def remove_all_exercises(self):
455
# XXX Refactor this - make it an instance method of Subject rather than a
456
# class method of Worksheet. Can't do that now because Subject isn't
457
# linked referentially to the Worksheet.
459
def get_by_name(cls, store, subjectname, worksheetname):
461
Get the Worksheet from the db associated with a given store, subject
462
name and worksheet name.
464
return store.find(cls, cls.subject == unicode(subjectname),
465
cls.name == unicode(worksheetname)).one()
467
def remove_all_exercises(self, store):
679
469
Remove all exercises from this worksheet.
680
470
This does not delete the exercises themselves. It just removes them
681
471
from the worksheet.
683
store = Store.of(self)
684
for ws_ex in self.all_worksheet_exercises:
685
if ws_ex.saves.count() > 0 or ws_ex.attempts.count() > 0:
686
raise IntegrityError()
687
473
store.find(WorksheetExercise,
688
474
WorksheetExercise.worksheet == self).remove()
690
476
def get_permissions(self, user):
691
477
return self.offering.get_permissions(user)
694
"""Returns the xml of this worksheet, converts from rst if required."""
695
if self.format == u'rst':
696
ws_xml = rst(self.data)
702
"""Deletes the worksheet, provided it has no attempts on any exercises.
704
Returns True if delete succeeded, or False if this worksheet has
705
attempts attached."""
706
for ws_ex in self.all_worksheet_exercises:
707
if ws_ex.saves.count() > 0 or ws_ex.attempts.count() > 0:
708
raise IntegrityError()
710
self.remove_all_exercises()
711
Store.of(self).remove(self)
713
479
class WorksheetExercise(Storm):
714
__storm_table__ = "worksheet_exercise"
716
id = Int(primary=True, name="ws_ex_id")
480
__storm_table__ = "worksheet_problem"
481
__storm_primary__ = "worksheet_id", "exercise_id"
718
483
worksheet_id = Int(name="worksheetid")
719
484
worksheet = Reference(worksheet_id, Worksheet.id)
720
exercise_id = Unicode(name="exerciseid")
485
exercise_id = Unicode(name="problemid")
721
486
exercise = Reference(exercise_id, Exercise.id)
722
487
optional = Bool()
726
saves = ReferenceSet(id, "ExerciseSave.ws_ex_id")
727
attempts = ReferenceSet(id, "ExerciseAttempt.ws_ex_id")
729
489
__init__ = _kwarg_init
731
491
def __repr__(self):
732
492
return "<%s %s in %s>" % (type(self).__name__, self.exercise.name,
733
self.worksheet.identifier)
735
def get_permissions(self, user):
736
return self.worksheet.get_permissions(user)
739
495
class ExerciseSave(Storm):
793
550
__storm_primary__ = "exercise_id", "suiteid"
796
exercise_id = Unicode(name="exerciseid")
553
exercise_id = Unicode(name="problemid")
797
554
description = Unicode()
799
556
function = Unicode()
800
557
stdin = Unicode()
801
558
exercise = Reference(exercise_id, Exercise.id)
802
test_cases = ReferenceSet(suiteid, 'TestCase.suiteid', order_by="seq_no")
803
variables = ReferenceSet(suiteid, 'TestSuiteVar.suiteid', order_by='arg_no')
806
"""Delete this suite, without asking questions."""
807
for vaariable in self.variables:
809
for test_case in self.test_cases:
811
Store.of(self).remove(self)
559
test_cases = ReferenceSet(suiteid, 'TestCase.suiteid')
560
variables = ReferenceSet(suiteid, 'TestSuiteVar.suiteid')
813
562
class TestCase(Storm):
814
563
"""A TestCase is a member of a TestSuite.
added
removed
ivle/database.py
