~azzar1/unity/add-show-desktop-key
» Revision
1235
(compared to revision 1294.2.118)
: ivle/database.py
« back to all changes in this revision
Viewing changes to ivle/database.py
- browse files at revision 1235
- compare with another revision
- download diff
- download tarball
- view history from revision 1235
- Committer: Matt Giuca
- Date: 2009-04-28 11:19:03 UTC
- Revision ID: matt.giuca@gmail.com-20090428111903-murkoqeljahrp2d8
usrmgt-server: Removed all references to ivle.conf. Now uses the config
object.
(I created a global variable, config, just for the outermost functions to
use. All of the other functions still use an argument version of config,
for testing purposes).
object.
(I created a global variable, config, just for the outermost functions to
use. All of the other functions still use an argument version of config,
for testing purposes).
- files added:
- ivle/webapp/admin/enrol.html
- files removed:
- bin/ivle-fetchsubmissions
- ivle/webapp/admin/templates
- ivle/webapp/publisher
- files renamed:
- bin/ivle-adduser => bin/ivle-makeuser
- files modified:
- bin/ivle-buildjail
added
removed
ivle/database.py
17
17
18
18
# Author: Matt Giuca, Will Grant
19
19
20
"""Database utilities and content classes.
20
"""
21
Database Classes and Utilities for Storm ORM
21
22
22
23
This module provides all of the classes which map to database tables.
23
24
It also provides miscellaneous utility functions for database interaction.
28
29
29
30
from storm.locals import create_database, Store, Int, Unicode, DateTime, \
30
31
Reference, ReferenceSet, Bool, Storm, Desc
31
from storm.expr import Select, Max
32
32
from storm.exceptions import NotOneError, IntegrityError
33
33
34
34
from ivle.worksheet.rst import rst
80
80
# USERS #
81
81
82
82
class User(Storm):
83
"""An IVLE user account."""
83
"""
84
Represents an IVLE user.
85
"""
84
86
__storm_table__ = "login"
85
87
86
88
id = Int(primary=True, name="loginid")
117
119
118
120
@property
119
121
def display_name(self):
120
"""Returns the "nice name" of the user or group."""
121
122
return self.fullname
122
123
123
124
@property
124
def short_name(self):
125
"""Returns the database "identifier" name of the user or group."""
126
return self.login
127
128
@property
129
125
def password_expired(self):
130
126
fieldval = self.pass_exp
131
127
return fieldval is not None and datetime.datetime.now() > fieldval
168
164
169
165
# TODO: Invitations should be listed too?
170
166
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
167
preds = [
176
168
ProjectGroupMembership.user_id == self.id,
177
169
ProjectGroup.id == ProjectGroupMembership.project_group_id,
198
190
return self._get_enrolments(False)
199
191
200
192
def get_projects(self, offering=None, active_only=True):
201
"""Find projects that the user can submit.
193
'''Return Projects that the user can submit.
202
194
203
195
This will include projects for offerings in which the user is
204
196
enrolled, as long as the project is not in a project set which has
205
197
groups (ie. if maximum number of group members is 0).
206
198
207
@param active_only: Whether to only search active offerings.
208
@param offering: An optional offering to restrict the search to.
209
"""
199
Unless active_only is False, only projects for active offerings will
200
be returned.
201
202
If an offering is specified, returned projects will be limited to
203
those for that offering.
204
'''
210
205
return Store.of(self).find(Project,
211
206
Project.project_set_id == ProjectSet.id,
212
207
ProjectSet.max_students_per_group == None,
219
214
220
215
@staticmethod
221
216
def hash_password(password):
222
"""Hash a password with MD5."""
223
217
return hashlib.md5(password).hexdigest()
224
218
225
219
@classmethod
226
220
def get_by_login(cls, store, login):
227
"""Find a user in a store by login name."""
221
"""
222
Get the User from the db associated with a given store and
223
login.
224
"""
228
225
return store.find(cls, cls.login == unicode(login)).one()
229
226
230
227
def get_permissions(self, user):
231
"""Determine privileges held by a user over this object.
232
233
If the user requesting privileges is this user or an admin,
234
they may do everything. Otherwise they may do nothing.
235
"""
236
228
if user and user.admin or user is self:
237
229
return set(['view', 'edit', 'submit_project'])
238
230
else:
241
233
# SUBJECTS AND ENROLMENTS #
242
234
243
235
class Subject(Storm):
244
"""A subject (or course) which is run in some semesters."""
245
246
236
__storm_table__ = "subject"
247
237
248
238
id = Int(primary=True, name="subjectid")
259
249
return "<%s '%s'>" % (type(self).__name__, self.short_name)
260
250
261
251
def get_permissions(self, user):
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
252
perms = set()
268
253
if user is not None:
269
254
perms.add('view')
272
257
return perms
273
258
274
259
def active_offerings(self):
275
"""Find active offerings for this subject.
276
277
Return a sequence of currently active offerings for this subject
260
"""Return a sequence of currently active offerings for this subject
278
261
(offerings whose semester.state is "current"). There should be 0 or 1
279
262
elements in this sequence, but it's possible there are more.
280
263
"""
282
265
Semester.state == u'current')
283
266
284
267
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
"""
268
"""Get the offering for the given year/semester, or None."""
290
269
return self.offerings.find(Offering.semester_id == Semester.id,
291
270
Semester.year == unicode(year),
292
271
Semester.semester == unicode(semester)).one()
293
272
294
273
class Semester(Storm):
295
"""A semester in which subjects can be run."""
296
297
274
__storm_table__ = "semester"
298
275
299
276
id = Int(primary=True, name="semesterid")
313
290
return "<%s %s/%s>" % (type(self).__name__, self.year, self.semester)
314
291
315
292
class Offering(Storm):
316
"""An offering of a subject in a particular semester."""
317
318
293
__storm_table__ = "offering"
319
294
320
295
id = Int(primary=True, name="offeringid")
343
318
self.semester)
344
319
345
320
def enrol(self, user, role=u'student'):
346
"""Enrol a user in this offering.
347
348
Enrolments handle both the staff and student cases. The role controls
349
the privileges granted by this enrolment.
350
"""
321
'''Enrol a user in this offering.'''
351
322
enrolment = Store.of(self).find(Enrolment,
352
323
Enrolment.user_id == user.id,
353
324
Enrolment.offering_id == self.id).one()
378
349
return perms
379
350
380
351
def get_enrolment(self, user):
381
"""Find the user's enrolment in this offering."""
382
352
try:
383
353
enrolment = self.enrolments.find(user=user).one()
384
354
except NotOneError:
386
356
387
357
return enrolment
388
358
389
def get_members_by_role(self, role):
390
return Store.of(self).find(User,
391
Enrolment.user_id == User.id,
392
Enrolment.offering_id == self.id,
393
Enrolment.role == role
394
)
395
396
@property
397
def students(self):
398
return self.get_members_by_role(u'student')
399
400
359
class Enrolment(Storm):
401
"""An enrolment of a user in an offering.
402
403
This represents the roles of both staff and students.
404
"""
405
406
360
__storm_table__ = "enrolment"
407
361
__storm_primary__ = "user_id", "offering_id"
408
362
431
385
# PROJECTS #
432
386
433
387
class ProjectSet(Storm):
434
"""A set of projects that share common groups.
435
436
Each student project group is attached to a project set. The group is
437
valid for all projects in the group's set.
438
"""
439
440
388
__storm_table__ = "project_set"
441
389
442
390
id = Int(name="projectsetid", primary=True)
453
401
return "<%s %d in %r>" % (type(self).__name__, self.id,
454
402
self.offering)
455
403
456
def get_permissions(self, user):
457
return self.offering.get_permissions(user)
458
459
@property
460
def assigned(self):
461
"""Get the entities (groups or users) assigned to submit this project.
462
463
This will be a Storm ResultSet.
464
"""
465
#If its a solo project, return everyone in offering
466
if self.max_students_per_group is None:
467
return self.offering.students
468
else:
469
return self.project_groups
470
471
404
class Project(Storm):
472
"""A student project for which submissions can be made."""
473
474
405
__storm_table__ = "project"
475
406
476
407
id = Int(name="projectid", primary=True)
501
432
def submit(self, principal, path, revision, who):
502
433
"""Submit a Subversion path and revision to a project.
503
434
504
@param principal: The owner of the Subversion repository, and the
505
entity on behalf of whom the submission is being made
506
@param path: A path within that repository to submit.
507
@param revision: The revision of that path to submit.
508
@param who: The user who is actually making the submission.
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.
509
439
"""
510
440
511
441
if not self.can_submit(principal):
521
451
522
452
return ps
523
453
524
def get_permissions(self, user):
525
return self.project_set.offering.get_permissions(user)
526
527
@property
528
def latest_submissions(self):
529
"""Return the latest submission for each Assessed."""
530
return Store.of(self).find(ProjectSubmission,
531
Assessed.project_id == self.id,
532
ProjectSubmission.assessed_id == Assessed.id,
533
ProjectSubmission.date_submitted == Select(
534
Max(ProjectSubmission.date_submitted),
535
ProjectSubmission.assessed_id == Assessed.id,
536
tables=ProjectSubmission
537
)
538
)
539
540
454
541
455
class ProjectGroup(Storm):
542
"""A group of students working together on a project."""
543
544
456
__storm_table__ = "project_group"
545
457
546
458
id = Int(name="groupid", primary=True)
565
477
566
478
@property
567
479
def display_name(self):
568
"""Returns the "nice name" of the user or group."""
569
return self.nick
570
571
@property
572
def short_name(self):
573
"""Returns the database "identifier" name of the user or group."""
574
return self.name
480
return '%s (%s)' % (self.nick, self.name)
575
481
576
482
def get_projects(self, offering=None, active_only=True):
577
'''Find projects that the group can submit.
483
'''Return Projects that the group can submit.
578
484
579
485
This will include projects in the project set which owns this group,
580
486
unless the project set disallows groups (in which case none will be
581
487
returned).
582
488
583
@param active_only: Whether to only search active offerings.
584
@param offering: An optional offering to restrict the search to.
489
Unless active_only is False, projects will only be returned if the
490
group's offering is active.
491
492
If an offering is specified, projects will only be returned if it
493
matches the group's.
585
494
'''
586
495
return Store.of(self).find(Project,
587
496
Project.project_set_id == ProjectSet.id,
600
509
return set()
601
510
602
511
class ProjectGroupMembership(Storm):
603
"""A student's membership in a project group."""
604
605
512
__storm_table__ = "group_member"
606
513
__storm_primary__ = "user_id", "project_group_id"
607
514
617
524
self.project_group)
618
525
619
526
class Assessed(Storm):
620
"""A composite of a user or group combined with a project.
621
622
Each project submission and extension refers to an Assessed. It is the
623
sole specifier of the repository and project.
624
"""
625
626
527
__storm_table__ = "assessed"
627
528
628
529
id = Int(name="assessedid", primary=True)
641
542
return "<%s %r in %r>" % (type(self).__name__,
642
543
self.user or self.project_group, self.project)
643
544
644
@property
645
def is_group(self):
646
"""True if the Assessed is a group, False if it is a user."""
647
return self.project_group is not None
648
649
@property
650
def principal(self):
651
return self.project_group or self.user
652
653
545
@classmethod
654
546
def get(cls, store, principal, project):
655
"""Find or create an Assessed for the given user or group and project.
656
657
@param principal: The user or group.
658
@param project: The project.
659
"""
660
547
t = type(principal)
661
548
if t not in (User, ProjectGroup):
662
549
raise AssertionError('principal must be User or ProjectGroup')
679
566
680
567
681
568
class ProjectExtension(Storm):
682
"""An extension granted to a user or group on a particular project.
683
684
The user or group and project are specified by the Assessed.
685
"""
686
687
569
__storm_table__ = "project_extension"
688
570
689
571
id = Int(name="extensionid", primary=True)
695
577
notes = Unicode()
696
578
697
579
class ProjectSubmission(Storm):
698
"""A submission from a user or group repository to a particular project.
699
700
The content of a submission is a single path and revision inside a
701
repository. The repository is that owned by the submission's user and
702
group, while the path and revision are explicit.
703
704
The user or group and project are specified by the Assessed.
705
"""
706
707
580
__storm_table__ = "project_submission"
708
581
709
582
id = Int(name="submissionid", primary=True)
719
592
# WORKSHEETS AND EXERCISES #
720
593
721
594
class Exercise(Storm):
722
"""An exercise for students to complete in a worksheet.
723
724
An exercise may be present in any number of worksheets.
725
"""
726
727
595
__storm_table__ = "exercise"
728
596
id = Unicode(primary=True, name="identifier")
729
597
name = Unicode()
741
609
'WorksheetExercise.worksheet_id',
742
610
'Worksheet.id'
743
611
)
744
612
745
613
test_suites = ReferenceSet(id,
746
614
'TestSuite.exercise_id',
747
615
order_by='seq_no')
758
626
if user.admin:
759
627
perms.add('edit')
760
628
perms.add('view')
761
elif u'lecturer' in set((e.role for e in user.active_enrolments)):
762
perms.add('edit')
763
perms.add('view')
764
elif u'tutor' in set((e.role for e in user.active_enrolments)):
765
perms.add('edit')
766
perms.add('view')
767
629
elif 'lecturer' in set((e.role for e in user.active_enrolments)):
630
perms.add('edit')
631
perms.add('view')
632
768
633
return perms
769
634
770
635
def get_description(self):
771
"""Return the description interpreted as reStructuredText."""
772
636
return rst(self.description)
773
637
774
638
def delete(self):
780
644
Store.of(self).remove(self)
781
645
782
646
class Worksheet(Storm):
783
"""A worksheet with exercises for students to complete.
784
785
Worksheets are owned by offerings.
786
"""
787
788
647
__storm_table__ = "worksheet"
789
648
790
649
id = Int(primary=True, name="worksheetid")
816
675
return "<%s %s>" % (type(self).__name__, self.name)
817
676
818
677
def remove_all_exercises(self):
819
"""Remove all exercises from this worksheet.
820
678
"""
679
Remove all exercises from this worksheet.
821
680
This does not delete the exercises themselves. It just removes them
822
681
from the worksheet.
823
682
"""
827
686
raise IntegrityError()
828
687
store.find(WorksheetExercise,
829
688
WorksheetExercise.worksheet == self).remove()
830
689
831
690
def get_permissions(self, user):
832
691
return self.offering.get_permissions(user)
833
692
834
693
def get_xml(self):
835
694
"""Returns the xml of this worksheet, converts from rst if required."""
836
695
if self.format == u'rst':
838
697
return ws_xml
839
698
else:
840
699
return self.data
841
700
842
701
def delete(self):
843
702
"""Deletes the worksheet, provided it has no attempts on any exercises.
844
703
845
704
Returns True if delete succeeded, or False if this worksheet has
846
705
attempts attached."""
847
706
for ws_ex in self.all_worksheet_exercises:
848
707
if ws_ex.saves.count() > 0 or ws_ex.attempts.count() > 0:
849
708
raise IntegrityError()
850
709
851
710
self.remove_all_exercises()
852
711
Store.of(self).remove(self)
853
712
854
713
class WorksheetExercise(Storm):
855
"""A link between a worksheet and one of its exercises.
856
857
These may be marked optional, in which case the exercise does not count
858
for marking purposes. The sequence number is used to order the worksheet
859
ToC.
860
"""
861
862
714
__storm_table__ = "worksheet_exercise"
863
715
864
716
id = Int(primary=True, name="ws_ex_id")
865
717
866
718
worksheet_id = Int(name="worksheetid")
870
722
optional = Bool()
871
723
active = Bool()
872
724
seq_no = Int()
873
725
874
726
saves = ReferenceSet(id, "ExerciseSave.ws_ex_id")
875
727
attempts = ReferenceSet(id, "ExerciseAttempt.ws_ex_id")
876
728
882
734
883
735
def get_permissions(self, user):
884
736
return self.worksheet.get_permissions(user)
885
737
886
738
887
739
class ExerciseSave(Storm):
888
"""A potential exercise solution submitted by a user for storage.
889
890
This is not an actual tested attempt at an exercise, it's just a save of
891
the editing session.
892
"""
893
740
"""
741
Represents a potential solution to an exercise that a user has submitted
742
to the server for storage.
743
A basic ExerciseSave is just the current saved text for this exercise for
744
this user (doesn't count towards their attempts).
745
ExerciseSave may be extended with additional semantics (such as
746
ExerciseAttempt).
747
"""
894
748
__storm_table__ = "exercise_save"
895
749
__storm_primary__ = "ws_ex_id", "user_id"
896
750
909
763
self.exercise.name, self.user.login, self.date.strftime("%c"))
910
764
911
765
class ExerciseAttempt(ExerciseSave):
912
"""An attempt at solving an exercise.
913
914
This is a special case of ExerciseSave, used when the user submits a
915
candidate solution. Like an ExerciseSave, it constitutes exercise solution
916
data.
917
918
In addition, it contains information about the result of the submission:
919
920
- complete - True if this submission was successful, rendering this
921
exercise complete for this user in this worksheet.
922
- active - True if this submission is "active" (usually true).
923
Submissions may be de-activated by privileged users for
924
special reasons, and then they won't count (either as a
925
penalty or success), but will still be stored.
926
"""
927
766
"""
767
An ExerciseAttempt is a special case of an ExerciseSave. Like an
768
ExerciseSave, it constitutes exercise solution data that the user has
769
submitted to the server for storage.
770
In addition, it contains additional information about the submission.
771
complete - True if this submission was successful, rendering this exercise
772
complete for this user.
773
active - True if this submission is "active" (usually true). Submissions
774
may be de-activated by privileged users for special reasons, and then
775
they won't count (either as a penalty or success), but will still be
776
stored.
777
"""
928
778
__storm_table__ = "exercise_attempt"
929
779
__storm_primary__ = "ws_ex_id", "user_id", "date"
930
780
933
783
text = Unicode(name="attempt")
934
784
complete = Bool()
935
785
active = Bool()
936
786
937
787
def get_permissions(self, user):
938
788
return set(['view']) if user is self.user else set()
939
789
940
790
class TestSuite(Storm):
941
"""A container to group an exercise's test cases.
942
943
The test suite contains some information on how to test. The function to
944
test, variables to set and stdin data are stored here.
945
"""
946
791
"""A Testsuite acts as a container for the test cases of an exercise."""
947
792
__storm_table__ = "test_suite"
948
793
__storm_primary__ = "exercise_id", "suiteid"
949
794
950
795
suiteid = Int()
951
796
exercise_id = Unicode(name="exerciseid")
952
797
description = Unicode()
956
801
exercise = Reference(exercise_id, Exercise.id)
957
802
test_cases = ReferenceSet(suiteid, 'TestCase.suiteid', order_by="seq_no")
958
803
variables = ReferenceSet(suiteid, 'TestSuiteVar.suiteid', order_by='arg_no')
959
804
960
805
def delete(self):
961
806
"""Delete this suite, without asking questions."""
962
807
for vaariable in self.variables:
966
811
Store.of(self).remove(self)
967
812
968
813
class TestCase(Storm):
969
"""A container for actual tests (see TestCasePart), inside a test suite.
970
971
It is the lowest level shown to students on their pass/fail status."""
972
814
"""A TestCase is a member of a TestSuite.
815
816
It contains the data necessary to check if an exercise is correct"""
973
817
__storm_table__ = "test_case"
974
818
__storm_primary__ = "testid", "suiteid"
975
819
976
820
testid = Int()
977
821
suiteid = Int()
978
822
suite = Reference(suiteid, "TestSuite.suiteid")
980
824
failmsg = Unicode()
981
825
test_default = Unicode()
982
826
seq_no = Int()
983
827
984
828
parts = ReferenceSet(testid, "TestCasePart.testid")
985
829
986
830
__init__ = _kwarg_init
987
831
988
832
def delete(self):
989
833
for part in self.parts:
990
834
part.delete()
991
835
Store.of(self).remove(self)
992
836
993
837
class TestSuiteVar(Storm):
994
"""A variable used by an exercise test suite.
995
996
This may represent a function argument or a normal variable.
997
"""
998
838
"""A container for the arguments of a Test Suite"""
999
839
__storm_table__ = "suite_variable"
1000
840
__storm_primary__ = "varid"
1001
841
1002
842
varid = Int()
1003
843
suiteid = Int()
1004
844
var_name = Unicode()
1005
845
var_value = Unicode()
1006
846
var_type = Unicode()
1007
847
arg_no = Int()
1008
848
1009
849
suite = Reference(suiteid, "TestSuite.suiteid")
1010
850
1011
851
__init__ = _kwarg_init
1012
852
1013
853
def delete(self):
1014
854
Store.of(self).remove(self)
1015
855
1016
856
class TestCasePart(Storm):
1017
"""An actual piece of code to test an exercise solution."""
1018
857
"""A container for the test elements of a Test Case"""
1019
858
__storm_table__ = "test_case_part"
1020
859
__storm_primary__ = "partid"
1021
860
1022
861
partid = Int()
1023
862
testid = Int()
1024
863
1025
864
part_type = Unicode()
1026
865
test_type = Unicode()
1027
866
data = Unicode()
1028
867
filename = Unicode()
1029
868
1030
869
test = Reference(testid, "TestCase.testid")
1031
870
1032
871
__init__ = _kwarg_init
1033
872
1034
873
def delete(self):
1035
874
Store.of(self).remove(self)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1