85
76
ctx['semesters'].append((semester, offerings))
88
class SubjectsManage(XHTMLView):
89
'''Subject management view.'''
90
template = 'templates/subjects-manage.html'
93
def authorize(self, req):
94
return req.user is not None and req.user.admin
96
def populate(self, req, ctx):
98
ctx['mediapath'] = media_url(req, CorePlugin, 'images/')
99
ctx['SubjectEdit'] = SubjectEdit
100
ctx['SemesterEdit'] = SemesterEdit
102
ctx['subjects'] = req.store.find(Subject).order_by(Subject.name)
103
ctx['semesters'] = req.store.find(Semester).order_by(
104
Semester.year, Semester.semester)
107
class SubjectShortNameUniquenessValidator(formencode.FancyValidator):
108
"""A FormEncode validator that checks that a subject name is unused.
110
The subject referenced by state.existing_subject is permitted
111
to hold that name. If any other object holds it, the input is rejected.
113
def __init__(self, matching=None):
114
self.matching = matching
116
def _to_python(self, value, state):
117
if (state.store.find(
118
Subject, short_name=value).one() not in
119
(None, state.existing_subject)):
120
raise formencode.Invalid(
121
'Short name already taken', value, state)
125
class SubjectSchema(formencode.Schema):
126
short_name = formencode.All(
127
SubjectShortNameUniquenessValidator(),
128
formencode.validators.UnicodeString(not_empty=True))
129
name = formencode.validators.UnicodeString(not_empty=True)
130
code = formencode.validators.UnicodeString(not_empty=True)
133
class SubjectFormView(BaseFormView):
134
"""An abstract form to add or edit a subject."""
137
def authorize(self, req):
138
return req.user is not None and req.user.admin
140
def populate_state(self, state):
141
state.existing_subject = None
145
return SubjectSchema()
147
def get_return_url(self, obj):
151
class SubjectNew(SubjectFormView):
152
"""A form to create a subject."""
153
template = 'templates/subject-new.html'
155
def get_default_data(self, req):
158
def save_object(self, req, data):
159
new_subject = Subject()
160
new_subject.short_name = data['short_name']
161
new_subject.name = data['name']
162
new_subject.code = data['code']
164
req.store.add(new_subject)
168
class SubjectEdit(SubjectFormView):
169
"""A form to edit a subject."""
170
template = 'templates/subject-edit.html'
172
def populate_state(self, state):
173
state.existing_subject = self.context
175
def get_default_data(self, req):
177
'short_name': self.context.short_name,
178
'name': self.context.name,
179
'code': self.context.code,
182
def save_object(self, req, data):
183
self.context.short_name = data['short_name']
184
self.context.name = data['name']
185
self.context.code = data['code']
190
class SemesterUniquenessValidator(formencode.FancyValidator):
191
"""A FormEncode validator that checks that a semester is unique.
193
There cannot be more than one semester for the same year and semester.
195
def _to_python(self, value, state):
196
if (state.store.find(
197
Semester, year=value['year'], semester=value['semester']
198
).one() not in (None, state.existing_semester)):
199
raise formencode.Invalid(
200
'Semester already exists', value, state)
204
class SemesterSchema(formencode.Schema):
205
year = formencode.validators.UnicodeString()
206
semester = formencode.validators.UnicodeString()
207
state = formencode.All(
208
formencode.validators.OneOf(["past", "current", "future"]),
209
formencode.validators.UnicodeString())
210
chained_validators = [SemesterUniquenessValidator()]
213
class SemesterFormView(BaseFormView):
216
def authorize(self, req):
217
return req.user is not None and req.user.admin
221
return SemesterSchema()
223
def get_return_url(self, obj):
224
return '/subjects/+manage'
227
class SemesterNew(SemesterFormView):
228
"""A form to create a semester."""
229
template = 'templates/semester-new.html'
232
def populate_state(self, state):
233
state.existing_semester = None
235
def get_default_data(self, req):
238
def save_object(self, req, data):
239
new_semester = Semester()
240
new_semester.year = data['year']
241
new_semester.semester = data['semester']
242
new_semester.state = data['state']
244
req.store.add(new_semester)
248
class SemesterEdit(SemesterFormView):
249
"""A form to edit a semester."""
250
template = 'templates/semester-edit.html'
252
def populate_state(self, state):
253
state.existing_semester = self.context
255
def get_default_data(self, req):
257
'year': self.context.year,
258
'semester': self.context.semester,
259
'state': self.context.state,
262
def save_object(self, req, data):
263
self.context.year = data['year']
264
self.context.semester = data['semester']
265
self.context.state = data['state']
79
def format_submission_principal(user, principal):
80
"""Render a list of users to fit in the offering project listing.
82
Given a user and a list of submitters, returns 'solo' if the
83
only submitter is the user, or a string of the form
84
'with A, B and C' if there are any other submitters.
86
If submitters is None, we assume that the list of members could
87
not be determined, so we just return 'group'.
95
display_names = sorted(
96
member.display_name for member in principal.members
97
if member is not user)
99
if len(display_names) == 0:
100
return 'solo (%s)' % principal.name
101
elif len(display_names) == 1:
102
return 'with %s (%s)' % (display_names[0], principal.name)
103
elif len(display_names) > 5:
104
return 'with %d others (%s)' % (len(display_names), principal.name)
106
return 'with %s and %s (%s)' % (', '.join(display_names[:-1]),
107
display_names[-1], principal.name)
270
110
class OfferingView(XHTMLView):
310
147
problems_done, problems_total))
313
class SubjectValidator(formencode.FancyValidator):
314
"""A FormEncode validator that turns a subject name into a subject.
316
The state must have a 'store' attribute, which is the Storm store
319
def _to_python(self, value, state):
320
subject = state.store.find(Subject, short_name=value).one()
324
raise formencode.Invalid('Subject does not exist', value, state)
327
class SemesterValidator(formencode.FancyValidator):
328
"""A FormEncode validator that turns a string into a semester.
330
The string should be of the form 'year/semester', eg. '2009/1'.
332
The state must have a 'store' attribute, which is the Storm store
335
def _to_python(self, value, state):
337
year, semester = value.split('/')
339
year = semester = None
341
semester = state.store.find(
342
Semester, year=year, semester=semester).one()
346
raise formencode.Invalid('Semester does not exist', value, state)
349
class OfferingUniquenessValidator(formencode.FancyValidator):
350
"""A FormEncode validator that checks that an offering is unique.
352
There cannot be more than one offering in the same year and semester.
354
The offering referenced by state.existing_offering is permitted to
355
hold that year and semester tuple. If any other object holds it, the
358
def _to_python(self, value, state):
359
if (state.store.find(
360
Offering, subject=value['subject'],
361
semester=value['semester']).one() not in
362
(None, state.existing_offering)):
363
raise formencode.Invalid(
364
'Offering already exists', value, state)
368
150
class OfferingSchema(formencode.Schema):
369
151
description = formencode.validators.UnicodeString(
370
152
if_missing=None, not_empty=False)
371
153
url = formencode.validators.URL(if_missing=None, not_empty=False)
374
class OfferingAdminSchema(OfferingSchema):
375
subject = formencode.All(
376
SubjectValidator(), formencode.validators.UnicodeString())
377
semester = formencode.All(
378
SemesterValidator(), formencode.validators.UnicodeString())
379
chained_validators = [OfferingUniquenessValidator()]
382
class OfferingEdit(BaseFormView):
156
class OfferingEdit(XHTMLView):
383
157
"""A form to edit an offering's details."""
384
158
template = 'templates/offering-edit.html'
386
159
permission = 'edit'
390
if self.req.user.admin:
391
return OfferingAdminSchema()
161
def filter(self, stream, ctx):
162
return stream | HTMLFormFiller(data=ctx['data'])
164
def populate(self, req, ctx):
165
if req.method == 'POST':
166
data = dict(req.get_fieldstorage())
168
validator = OfferingSchema()
169
data = validator.to_python(data, state=req)
171
self.context.url = unicode(data['url']) if data['url'] else None
172
self.context.description = data['description']
174
req.throw_redirect(req.publisher.generate(self.context))
175
except formencode.Invalid, e:
176
errors = e.unpack_errors()
393
return OfferingSchema()
395
def populate(self, req, ctx):
396
super(OfferingEdit, self).populate(req, ctx)
397
ctx['subjects'] = req.store.find(Subject).order_by(Subject.name)
398
ctx['semesters'] = req.store.find(Semester).order_by(
399
Semester.year, Semester.semester)
401
def populate_state(self, state):
402
state.existing_offering = self.context
404
def get_default_data(self, req):
406
'subject': self.context.subject.short_name,
407
'semester': self.context.semester.year + '/' +
408
self.context.semester.semester,
409
'url': self.context.url,
410
'description': self.context.description,
179
'url': self.context.url,
180
'description': self.context.description,
413
def save_object(self, req, data):
415
self.context.subject = data['subject']
416
self.context.semester = data['semester']
417
self.context.description = data['description']
418
self.context.url = unicode(data['url']) if data['url'] else None
422
class OfferingNew(BaseFormView):
423
"""A form to create an offering."""
424
template = 'templates/offering-new.html'
427
def authorize(self, req):
428
return req.user is not None and req.user.admin
432
return OfferingAdminSchema()
434
def populate(self, req, ctx):
435
super(OfferingNew, self).populate(req, ctx)
436
ctx['subjects'] = req.store.find(Subject).order_by(Subject.name)
437
ctx['semesters'] = req.store.find(Semester).order_by(
438
Semester.year, Semester.semester)
440
def populate_state(self, state):
441
state.existing_offering = None
443
def get_default_data(self, req):
446
def save_object(self, req, data):
447
new_offering = Offering()
448
new_offering.subject = data['subject']
449
new_offering.semester = data['semester']
450
new_offering.description = data['description']
451
new_offering.url = unicode(data['url']) if data['url'] else None
453
req.store.add(new_offering)
457
class OfferingCloneWorksheetsSchema(formencode.Schema):
458
subject = formencode.All(
459
SubjectValidator(), formencode.validators.UnicodeString())
460
semester = formencode.All(
461
SemesterValidator(), formencode.validators.UnicodeString())
464
class OfferingCloneWorksheets(BaseFormView):
465
"""A form to clone worksheets from one offering to another."""
466
template = 'templates/offering-clone-worksheets.html'
469
def authorize(self, req):
470
return req.user is not None and req.user.admin
474
return OfferingCloneWorksheetsSchema()
476
def populate(self, req, ctx):
477
super(OfferingCloneWorksheets, self).populate(req, ctx)
478
ctx['subjects'] = req.store.find(Subject).order_by(Subject.name)
479
ctx['semesters'] = req.store.find(Semester).order_by(
480
Semester.year, Semester.semester)
482
def get_default_data(self, req):
485
def save_object(self, req, data):
486
if self.context.worksheets.count() > 0:
488
"Cannot clone to target with existing worksheets.")
489
offering = req.store.find(
490
Offering, subject=data['subject'], semester=data['semester']).one()
492
raise BadRequest("No such offering.")
493
if offering.worksheets.count() == 0:
494
raise BadRequest("Source offering has no worksheets.")
496
self.context.clone_worksheets(offering)
184
ctx['data'] = data or {}
185
ctx['context'] = self.context
186
ctx['errors'] = errors
500
189
class UserValidator(formencode.FancyValidator):
589
267
ctx['data'] = data or {}
590
268
ctx['offering'] = self.context
591
ctx['roles_auth'] = self.context.get_permissions(req.user, req.config)
269
ctx['roles_auth'] = self.context.get_permissions(req.user)
592
270
ctx['errors'] = errors
595
class EnrolmentEditSchema(formencode.Schema):
596
role = formencode.All(formencode.validators.OneOf(
597
["lecturer", "tutor", "student"]),
598
RoleEnrolmentValidator(),
599
formencode.validators.UnicodeString())
602
class EnrolmentEdit(BaseFormView):
603
"""A form to alter an enrolment's role."""
604
template = 'templates/enrolment-edit.html'
608
def populate_state(self, state):
609
state.offering = self.context.offering
611
def get_default_data(self, req):
612
return {'role': self.context.role}
616
return EnrolmentEditSchema()
618
def save_object(self, req, data):
619
self.context.role = data['role']
621
def get_return_url(self, obj):
622
return self.req.publisher.generate(
623
self.context.offering, EnrolmentsView)
625
def populate(self, req, ctx):
626
super(EnrolmentEdit, self).populate(req, ctx)
627
ctx['offering_perms'] = self.context.offering.get_permissions(
628
req.user, req.config)
631
class EnrolmentDelete(XHTMLView):
632
"""A form to alter an enrolment's role."""
633
template = 'templates/enrolment-delete.html'
637
def populate(self, req, ctx):
638
# If POSTing, delete delete delete.
639
if req.method == 'POST':
640
self.context.delete()
642
req.throw_redirect(req.publisher.generate(
643
self.context.offering, EnrolmentsView))
645
ctx['enrolment'] = self.context
648
272
class OfferingProjectsView(XHTMLView):
649
273
"""View the projects for an offering."""
650
274
template = 'templates/offering_projects.html'
651
275
permission = 'edit'
653
breadcrumb_text = 'Projects'
655
278
def populate(self, req, ctx):
656
279
self.plugin_styles[Plugin] = ["project.css"]
728
351
ctx['user'] = req.user
730
353
class Plugin(ViewPlugin, MediaPlugin):
731
forward_routes = (root_to_subject, root_to_semester, subject_to_offering,
732
offering_to_project, offering_to_projectset,
733
offering_to_enrolment)
735
subject_url, semester_url, offering_url, projectset_url, project_url,
354
forward_routes = (root_to_subject, subject_to_offering,
355
offering_to_project, offering_to_projectset)
356
reverse_routes = (subject_url, offering_url, projectset_url, project_url)
738
358
views = [(ApplicationRoot, ('subjects', '+index'), SubjectsView),
739
(ApplicationRoot, ('subjects', '+manage'), SubjectsManage),
740
(ApplicationRoot, ('subjects', '+new'), SubjectNew),
741
(ApplicationRoot, ('subjects', '+new-offering'), OfferingNew),
742
(ApplicationRoot, ('+semesters', '+new'), SemesterNew),
743
(Subject, '+edit', SubjectEdit),
744
(Semester, '+edit', SemesterEdit),
745
359
(Offering, '+index', OfferingView),
746
360
(Offering, '+edit', OfferingEdit),
747
(Offering, '+clone-worksheets', OfferingCloneWorksheets),
748
361
(Offering, ('+enrolments', '+index'), EnrolmentsView),
749
362
(Offering, ('+enrolments', '+new'), EnrolView),
750
(Enrolment, '+edit', EnrolmentEdit),
751
(Enrolment, '+delete', EnrolmentDelete),
752
363
(Offering, ('+projects', '+index'), OfferingProjectsView),
753
364
(Project, '+index', ProjectView),
added
removed
ivle/webapp/admin/subject.py
