← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ivle/webapp/admin/subject.py

  • Committer: William Grant
  • Date: 2010-02-17 06:48:28 UTC
  • Revision ID: grantw@unimelb.edu.au-20100217064828-dr43acvapzj45lic
Add a tiny bit of descriptive text to +clone-worksheets.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/webapp/admin/subject.py
27
27
import urllib
28
28
import urlparse
29
29
import cgi
30
 
import datetime
31
30
 
32
31
from storm.locals import Desc, Store
33
32
import genshi
34
33
from genshi.filters import HTMLFormFiller
35
 
from genshi.template import Context
 
34
from genshi.template import Context, TemplateLoader
36
35
import formencode
37
36
import formencode.validators
38
37
 
39
 
from ivle.webapp.base.forms import (BaseFormView, URLNameValidator,
40
 
                                    DateTimeValidator)
 
38
from ivle.webapp.base.forms import BaseFormView
41
39
from ivle.webapp.base.plugins import ViewPlugin, MediaPlugin
42
40
from ivle.webapp.base.xhtml import XHTMLView
43
 
from ivle.webapp.base.text import TextView
44
41
from ivle.webapp.errors import BadRequest
45
42
from ivle.webapp import ApplicationRoot
46
43
 
49
46
from ivle import util
50
47
import ivle.date
51
48
 
 
49
from ivle.webapp.admin.projectservice import ProjectSetRESTView
 
50
from ivle.webapp.admin.offeringservice import OfferingRESTView
52
51
from ivle.webapp.admin.publishing import (root_to_subject, root_to_semester,
53
52
            subject_to_offering, offering_to_projectset, offering_to_project,
54
 
            offering_to_enrolment, subject_url, semester_url, offering_url,
55
 
            projectset_url, project_url, enrolment_url)
 
53
            subject_url, semester_url, offering_url, projectset_url,
 
54
            project_url)
56
55
from ivle.webapp.admin.breadcrumbs import (SubjectBreadcrumb,
57
 
            OfferingBreadcrumb, UserBreadcrumb, ProjectBreadcrumb,
58
 
            ProjectsBreadcrumb, EnrolmentBreadcrumb)
 
56
            OfferingBreadcrumb, UserBreadcrumb, ProjectBreadcrumb)
59
57
from ivle.webapp.core import Plugin as CorePlugin
60
58
from ivle.webapp.groups import GroupsView
61
59
from ivle.webapp.media import media_url
65
63
    '''The view of the list of subjects.'''
66
64
    template = 'templates/subjects.html'
67
65
    tab = 'subjects'
68
 
    breadcrumb_text = "Subjects"
69
66
 
70
67
    def authorize(self, req):
71
68
        return req.user is not None
75
72
        ctx['user'] = req.user
76
73
        ctx['semesters'] = []
77
74
 
78
 
        for semester in req.store.find(Semester).order_by(
79
 
            Desc(Semester.year), Desc(Semester.display_name)):
 
75
        for semester in req.store.find(Semester).order_by(Desc(Semester.year),
 
76
                                                     Desc(Semester.semester)):
80
77
            if req.user.admin:
81
78
                # For admins, show all subjects in the system
82
79
                offerings = list(semester.offerings.find())
98
95
    def populate(self, req, ctx):
99
96
        ctx['req'] = req
100
97
        ctx['mediapath'] = media_url(req, CorePlugin, 'images/')
101
 
        ctx['SubjectView'] = SubjectView
102
98
        ctx['SubjectEdit'] = SubjectEdit
103
99
        ctx['SemesterEdit'] = SemesterEdit
104
100
 
105
101
        ctx['subjects'] = req.store.find(Subject).order_by(Subject.name)
106
102
        ctx['semesters'] = req.store.find(Semester).order_by(
107
 
            Semester.year, Semester.display_name)
108
 
 
109
 
 
110
 
class SubjectUniquenessValidator(formencode.FancyValidator):
111
 
    """A FormEncode validator that checks that a subject attribute is unique.
 
103
            Semester.year, Semester.semester)
 
104
 
 
105
 
 
106
class SubjectShortNameUniquenessValidator(formencode.FancyValidator):
 
107
    """A FormEncode validator that checks that a subject name is unused.
112
108
 
113
109
    The subject referenced by state.existing_subject is permitted
114
110
    to hold that name. If any other object holds it, the input is rejected.
115
 
 
116
 
    :param attribute: the name of the attribute to check.
117
 
    :param display: a string to identify the field in case of error.
118
111
    """
119
 
 
120
 
    def __init__(self, attribute, display):
121
 
        self.attribute = attribute
122
 
        self.display = display
 
112
    def __init__(self, matching=None):
 
113
        self.matching = matching
123
114
 
124
115
    def _to_python(self, value, state):
125
 
        if (state.store.find(Subject, **{self.attribute: value}).one() not in
 
116
        if (state.store.find(
 
117
                Subject, short_name=value).one() not in
126
118
                (None, state.existing_subject)):
127
119
            raise formencode.Invalid(
128
 
                '%s already taken' % self.display, value, state)
 
120
                'Short name already taken', value, state)
129
121
        return value
130
122
 
131
123
 
132
124
class SubjectSchema(formencode.Schema):
133
125
    short_name = formencode.All(
134
 
        SubjectUniquenessValidator('short_name', 'URL name'),
135
 
        URLNameValidator(not_empty=True))
136
 
    name = formencode.validators.UnicodeString(not_empty=True)
137
 
    code = formencode.All(
138
 
        SubjectUniquenessValidator('code', 'Subject code'),
 
126
        SubjectShortNameUniquenessValidator(),
139
127
        formencode.validators.UnicodeString(not_empty=True))
 
128
    name = formencode.validators.UnicodeString(not_empty=True)
 
129
    code = formencode.validators.UnicodeString(not_empty=True)
140
130
 
141
131
 
142
132
class SubjectFormView(BaseFormView):
153
143
    def validator(self):
154
144
        return SubjectSchema()
155
145
 
 
146
    def get_return_url(self, obj):
 
147
        return '/subjects'
 
148
 
156
149
 
157
150
class SubjectNew(SubjectFormView):
158
151
    """A form to create a subject."""
200
193
    """
201
194
    def _to_python(self, value, state):
202
195
        if (state.store.find(
203
 
                Semester, year=value['year'], url_name=value['url_name']
 
196
                Semester, year=value['year'], semester=value['semester']
204
197
                ).one() not in (None, state.existing_semester)):
205
198
            raise formencode.Invalid(
206
199
                'Semester already exists', value, state)
208
201
 
209
202
 
210
203
class SemesterSchema(formencode.Schema):
211
 
    year = URLNameValidator()
212
 
    code = formencode.validators.UnicodeString()
213
 
    url_name = URLNameValidator()
214
 
    display_name = formencode.validators.UnicodeString()
 
204
    year = formencode.validators.UnicodeString()
 
205
    semester = formencode.validators.UnicodeString()
215
206
    state = formencode.All(
216
207
        formencode.validators.OneOf(["past", "current", "future"]),
217
208
        formencode.validators.UnicodeString())
246
237
    def save_object(self, req, data):
247
238
        new_semester = Semester()
248
239
        new_semester.year = data['year']
249
 
        new_semester.code = data['code']
250
 
        new_semester.url_name = data['url_name']
251
 
        new_semester.display_name = data['display_name']
 
240
        new_semester.semester = data['semester']
252
241
        new_semester.state = data['state']
253
242
 
254
243
        req.store.add(new_semester)
265
254
    def get_default_data(self, req):
266
255
        return {
267
256
            'year': self.context.year,
268
 
            'code': self.context.code,
269
 
            'url_name': self.context.url_name,
270
 
            'display_name': self.context.display_name,
 
257
            'semester': self.context.semester,
271
258
            'state': self.context.state,
272
259
            }
273
260
 
274
261
    def save_object(self, req, data):
275
262
        self.context.year = data['year']
276
 
        self.context.code = data['code']
277
 
        self.context.url_name = data['url_name']
278
 
        self.context.display_name = data['display_name']
 
263
        self.context.semester = data['semester']
279
264
        self.context.state = data['state']
280
265
 
281
266
        return self.context
282
267
 
283
 
class SubjectView(XHTMLView):
284
 
    '''The view of the list of offerings in a given subject.'''
285
 
    template = 'templates/subject.html'
286
 
    tab = 'subjects'
287
 
 
288
 
    def authorize(self, req):
289
 
        return req.user is not None
290
 
 
291
 
    def populate(self, req, ctx):
292
 
        ctx['context'] = self.context
293
 
        ctx['req'] = req
294
 
        ctx['user'] = req.user
295
 
        ctx['offerings'] = list(self.context.offerings)
296
 
        ctx['permissions'] = self.context.get_permissions(req.user,req.config)
297
 
        ctx['SubjectEdit'] = SubjectEdit
298
 
        ctx['SubjectOfferingNew'] = SubjectOfferingNew
299
 
 
300
268
 
301
269
class OfferingView(XHTMLView):
302
270
    """The home page of an offering."""
316
284
        ctx['OfferingEdit'] = OfferingEdit
317
285
        ctx['OfferingCloneWorksheets'] = OfferingCloneWorksheets
318
286
        ctx['GroupsView'] = GroupsView
319
 
        ctx['EnrolmentsView'] = EnrolmentsView
320
 
        ctx['Project'] = ivle.database.Project
321
287
 
322
288
        # As we go, calculate the total score for this subject
323
289
        # (Assessable worksheets only, mandatory problems only)
324
290
 
325
291
        ctx['worksheets'], problems_total, problems_done = (
326
292
            ivle.worksheet.utils.create_list_of_fake_worksheets_and_stats(
327
 
                req.config, req.store, req.user, self.context,
328
 
                as_of=self.context.worksheet_cutoff))
 
293
                req.store, req.user, self.context))
329
294
 
330
295
        ctx['exercises_total'] = problems_total
331
296
        ctx['exercises_done'] = problems_done
372
337
            year = semester = None
373
338
 
374
339
        semester = state.store.find(
375
 
            Semester, year=year, url_name=semester).one()
 
340
            Semester, year=year, semester=semester).one()
376
341
        if semester:
377
342
            return semester
378
343
        else:
402
367
    description = formencode.validators.UnicodeString(
403
368
        if_missing=None, not_empty=False)
404
369
    url = formencode.validators.URL(if_missing=None, not_empty=False)
405
 
    worksheet_cutoff = DateTimeValidator(if_missing=None, not_empty=False)
406
 
    show_worksheet_marks = formencode.validators.StringBoolean(
407
 
        if_missing=False)
408
370
 
409
371
 
410
372
class OfferingAdminSchema(OfferingSchema):
432
394
        super(OfferingEdit, self).populate(req, ctx)
433
395
        ctx['subjects'] = req.store.find(Subject).order_by(Subject.name)
434
396
        ctx['semesters'] = req.store.find(Semester).order_by(
435
 
            Semester.year, Semester.display_name)
436
 
        ctx['force_subject'] = None
 
397
            Semester.year, Semester.semester)
437
398
 
438
399
    def populate_state(self, state):
439
400
        state.existing_offering = self.context
442
403
        return {
443
404
            'subject': self.context.subject.short_name,
444
405
            'semester': self.context.semester.year + '/' +
445
 
                        self.context.semester.url_name,
 
406
                        self.context.semester.semester,
446
407
            'url': self.context.url,
447
408
            'description': self.context.description,
448
 
            'worksheet_cutoff': self.context.worksheet_cutoff,
449
 
            'show_worksheet_marks': self.context.show_worksheet_marks,
450
409
            }
451
410
 
452
411
    def save_object(self, req, data):
455
414
            self.context.semester = data['semester']
456
415
        self.context.description = data['description']
457
416
        self.context.url = unicode(data['url']) if data['url'] else None
458
 
        self.context.worksheet_cutoff = data['worksheet_cutoff']
459
 
        self.context.show_worksheet_marks = data['show_worksheet_marks']
460
417
        return self.context
461
418
 
462
419
 
476
433
        super(OfferingNew, self).populate(req, ctx)
477
434
        ctx['subjects'] = req.store.find(Subject).order_by(Subject.name)
478
435
        ctx['semesters'] = req.store.find(Semester).order_by(
479
 
            Semester.year, Semester.display_name)
480
 
        ctx['force_subject'] = None
 
436
            Semester.year, Semester.semester)
481
437
 
482
438
    def populate_state(self, state):
483
439
        state.existing_offering = None
491
447
        new_offering.semester = data['semester']
492
448
        new_offering.description = data['description']
493
449
        new_offering.url = unicode(data['url']) if data['url'] else None
494
 
        new_offering.worksheet_cutoff = data['worksheet_cutoff']
495
 
        new_offering.show_worksheet_marks = data['show_worksheet_marks']
496
450
 
497
451
        req.store.add(new_offering)
498
452
        return new_offering
499
453
 
500
 
class SubjectOfferingNew(OfferingNew):
501
 
    """A form to create an offering for a given subject."""
502
 
    # Identical to OfferingNew, except it forces the subject to be the subject
503
 
    # in context
504
 
    def populate(self, req, ctx):
505
 
        super(SubjectOfferingNew, self).populate(req, ctx)
506
 
        ctx['force_subject'] = self.context
507
454
 
508
455
class OfferingCloneWorksheetsSchema(formencode.Schema):
509
456
    subject = formencode.All(
528
475
        super(OfferingCloneWorksheets, self).populate(req, ctx)
529
476
        ctx['subjects'] = req.store.find(Subject).order_by(Subject.name)
530
477
        ctx['semesters'] = req.store.find(Semester).order_by(
531
 
            Semester.year, Semester.display_name)
 
478
            Semester.year, Semester.semester)
532
479
 
533
480
    def get_default_data(self, req):
534
481
        return {}
599
546
    template = 'templates/enrolments.html'
600
547
    tab = 'subjects'
601
548
    permission = 'edit'
602
 
    breadcrumb_text = 'Enrolments'
603
549
 
604
550
    def populate(self, req, ctx):
605
 
        ctx['req'] = req
606
551
        ctx['offering'] = self.context
607
 
        ctx['mediapath'] = media_url(req, CorePlugin, 'images/')
608
 
        ctx['offering_perms'] = self.context.get_permissions(
609
 
            req.user, req.config)
610
 
        ctx['EnrolView'] = EnrolView
611
 
        ctx['EnrolmentEdit'] = EnrolmentEdit
612
 
        ctx['EnrolmentDelete'] = EnrolmentDelete
613
 
 
614
552
 
615
553
class EnrolView(XHTMLView):
616
554
    """A form to enrol a user in an offering."""
641
579
        ctx['offering'] = self.context
642
580
        ctx['roles_auth'] = self.context.get_permissions(req.user, req.config)
643
581
        ctx['errors'] = errors
644
 
        # If all of the fields validated, set the global form error.
645
 
        if isinstance(errors, basestring):
646
 
            ctx['error_value'] = errors
647
 
 
648
 
 
649
 
class EnrolmentEditSchema(formencode.Schema):
650
 
    role = formencode.All(formencode.validators.OneOf(
651
 
                                ["lecturer", "tutor", "student"]),
652
 
                          RoleEnrolmentValidator(),
653
 
                          formencode.validators.UnicodeString())
654
 
 
655
 
 
656
 
class EnrolmentEdit(BaseFormView):
657
 
    """A form to alter an enrolment's role."""
658
 
    template = 'templates/enrolment-edit.html'
659
 
    tab = 'subjects'
660
 
    permission = 'edit'
661
 
 
662
 
    def populate_state(self, state):
663
 
        state.offering = self.context.offering
664
 
 
665
 
    def get_default_data(self, req):
666
 
        return {'role': self.context.role}
667
 
 
668
 
    @property
669
 
    def validator(self):
670
 
        return EnrolmentEditSchema()
671
 
 
672
 
    def save_object(self, req, data):
673
 
        self.context.role = data['role']
674
 
 
675
 
    def get_return_url(self, obj):
676
 
        return self.req.publisher.generate(
677
 
            self.context.offering, EnrolmentsView)
678
 
 
679
 
    def populate(self, req, ctx):
680
 
        super(EnrolmentEdit, self).populate(req, ctx)
681
 
        ctx['offering_perms'] = self.context.offering.get_permissions(
682
 
            req.user, req.config)
683
 
 
684
 
 
685
 
class EnrolmentDelete(XHTMLView):
686
 
    """A form to alter an enrolment's role."""
687
 
    template = 'templates/enrolment-delete.html'
688
 
    tab = 'subjects'
689
 
    permission = 'edit'
690
 
 
691
 
    def populate(self, req, ctx):
692
 
        # If POSTing, delete delete delete.
693
 
        if req.method == 'POST':
694
 
            self.context.delete()
695
 
            req.store.commit()
696
 
            req.throw_redirect(req.publisher.generate(
697
 
                self.context.offering, EnrolmentsView))
698
 
 
699
 
        ctx['enrolment'] = self.context
700
 
 
701
582
 
702
583
class OfferingProjectsView(XHTMLView):
703
584
    """View the projects for an offering."""
704
585
    template = 'templates/offering_projects.html'
705
586
    permission = 'edit'
706
587
    tab = 'subjects'
707
 
    breadcrumb_text = 'Projects'
708
588
 
709
589
    def populate(self, req, ctx):
710
590
        self.plugin_styles[Plugin] = ["project.css"]
 
591
        self.plugin_scripts[Plugin] = ["project.js"]
711
592
        ctx['req'] = req
712
593
        ctx['offering'] = self.context
713
594
        ctx['projectsets'] = []
 
595
        ctx['OfferingRESTView'] = OfferingRESTView
714
596
 
715
597
        #Open the projectset Fragment, and render it for inclusion
716
598
        #into the ProjectSets page
 
599
        #XXX: This could be a lot cleaner
 
600
        loader = genshi.template.TemplateLoader(".", auto_reload=True)
 
601
 
717
602
        set_fragment = os.path.join(os.path.dirname(__file__),
718
603
                "templates/projectset_fragment.html")
719
604
        project_fragment = os.path.join(os.path.dirname(__file__),
720
605
                "templates/project_fragment.html")
721
606
 
722
 
        for projectset in \
723
 
            self.context.project_sets.order_by(ivle.database.ProjectSet.id):
724
 
            settmpl = self._loader.load(set_fragment)
 
607
        for projectset in self.context.project_sets:
 
608
            settmpl = loader.load(set_fragment)
725
609
            setCtx = Context()
726
610
            setCtx['req'] = req
727
611
            setCtx['projectset'] = projectset
728
612
            setCtx['projects'] = []
729
613
            setCtx['GroupsView'] = GroupsView
730
 
            setCtx['ProjectSetEdit'] = ProjectSetEdit
731
 
            setCtx['ProjectNew'] = ProjectNew
 
614
            setCtx['ProjectSetRESTView'] = ProjectSetRESTView
732
615
 
733
 
            for project in \
734
 
                projectset.projects.order_by(ivle.database.Project.deadline):
735
 
                projecttmpl = self._loader.load(project_fragment)
 
616
            for project in projectset.projects:
 
617
                projecttmpl = loader.load(project_fragment)
736
618
                projectCtx = Context()
737
619
                projectCtx['req'] = req
738
620
                projectCtx['project'] = project
739
 
                projectCtx['ProjectEdit'] = ProjectEdit
740
 
                projectCtx['ProjectDelete'] = ProjectDelete
741
621
 
742
622
                setCtx['projects'].append(
743
623
                        projecttmpl.generate(projectCtx))
751
631
    permission = "view_project_submissions"
752
632
    tab = 'subjects'
753
633
 
 
634
    def build_subversion_url(self, svnroot, submission):
 
635
        princ = submission.assessed.principal
 
636
 
 
637
        if isinstance(princ, User):
 
638
            path = 'users/%s' % princ.login
 
639
        else:
 
640
            path = 'groups/%s_%s_%s_%s' % (
 
641
                    princ.project_set.offering.subject.short_name,
 
642
                    princ.project_set.offering.semester.year,
 
643
                    princ.project_set.offering.semester.semester,
 
644
                    princ.name
 
645
                    )
 
646
        return urlparse.urljoin(
 
647
                    svnroot,
 
648
                    os.path.join(path, submission.path[1:] if
 
649
                                       submission.path.startswith(os.sep) else
 
650
                                       submission.path))
 
651
 
754
652
    def populate(self, req, ctx):
755
653
        self.plugin_styles[Plugin] = ["project.css"]
756
654
 
757
655
        ctx['req'] = req
758
 
        ctx['permissions'] = self.context.get_permissions(req.user,req.config)
759
656
        ctx['GroupsView'] = GroupsView
760
657
        ctx['EnrolView'] = EnrolView
761
 
        ctx['format_datetime'] = ivle.date.make_date_nice
762
 
        ctx['format_datetime_short'] = ivle.date.format_datetime_for_paragraph
763
 
        ctx['project'] = self.context
764
 
        ctx['user'] = req.user
765
 
        ctx['ProjectEdit'] = ProjectEdit
766
 
        ctx['ProjectDelete'] = ProjectDelete
767
 
        ctx['ProjectExport'] = ProjectBashExportView
768
 
 
769
 
class ProjectBashExportView(TextView):
770
 
    """Produce a Bash script for exporting projects"""
771
 
    template = "templates/project-export.sh"
772
 
    content_type = "text/x-sh"
773
 
    permission = "view_project_submissions"
774
 
 
775
 
    def populate(self, req, ctx):
776
 
        ctx['req'] = req
777
 
        ctx['permissions'] = self.context.get_permissions(req.user,req.config)
778
 
        ctx['format_datetime'] = ivle.date.make_date_nice
779
 
        ctx['format_datetime_short'] = ivle.date.format_datetime_for_paragraph
780
 
        ctx['project'] = self.context
781
 
        ctx['user'] = req.user
782
 
        ctx['now'] = datetime.datetime.now()
783
 
        ctx['format_datetime'] = ivle.date.make_date_nice
784
 
        ctx['format_datetime_short'] = ivle.date.format_datetime_for_paragraph
785
 
 
786
 
class ProjectUniquenessValidator(formencode.FancyValidator):
787
 
    """A FormEncode validator that checks that a project short_name is unique
788
 
    in a given offering.
789
 
 
790
 
    The project referenced by state.existing_project is permitted to
791
 
    hold that short_name. If any other project holds it, the input is rejected.
792
 
    """
793
 
    def _to_python(self, value, state):
794
 
        if (state.store.find(
795
 
            Project,
796
 
            Project.short_name == unicode(value),
797
 
            Project.project_set_id == ProjectSet.id,
798
 
            ProjectSet.offering == state.offering).one() not in
799
 
            (None, state.existing_project)):
800
 
            raise formencode.Invalid(
801
 
                "A project with that URL name already exists in this offering."
802
 
                , value, state)
803
 
        return value
804
 
 
805
 
class ProjectSchema(formencode.Schema):
806
 
    name = formencode.validators.UnicodeString(not_empty=True)
807
 
    short_name = formencode.All(
808
 
        URLNameValidator(not_empty=True),
809
 
        ProjectUniquenessValidator())
810
 
    deadline = DateTimeValidator(not_empty=True)
811
 
    url = formencode.validators.URL(if_missing=None, not_empty=False)
812
 
    synopsis = formencode.validators.UnicodeString(not_empty=True)
813
 
 
814
 
class ProjectEdit(BaseFormView):
815
 
    """A form to edit a project."""
816
 
    template = 'templates/project-edit.html'
817
 
    tab = 'subjects'
818
 
    permission = 'edit'
819
 
 
820
 
    @property
821
 
    def validator(self):
822
 
        return ProjectSchema()
823
 
 
824
 
    def populate(self, req, ctx):
825
 
        super(ProjectEdit, self).populate(req, ctx)
826
 
        ctx['projectset'] = self.context.project_set
827
 
 
828
 
    def populate_state(self, state):
829
 
        state.offering = self.context.project_set.offering
830
 
        state.existing_project = self.context
831
 
 
832
 
    def get_default_data(self, req):
833
 
        return {
834
 
            'name':         self.context.name,
835
 
            'short_name':   self.context.short_name,
836
 
            'deadline':     self.context.deadline,
837
 
            'url':          self.context.url,
838
 
            'synopsis':     self.context.synopsis,
839
 
            }
840
 
 
841
 
    def save_object(self, req, data):
842
 
        self.context.name = data['name']
843
 
        self.context.short_name = data['short_name']
844
 
        self.context.deadline = data['deadline']
845
 
        self.context.url = unicode(data['url']) if data['url'] else None
846
 
        self.context.synopsis = data['synopsis']
847
 
        return self.context
848
 
 
849
 
class ProjectNew(BaseFormView):
850
 
    """A form to create a new project."""
851
 
    template = 'templates/project-new.html'
852
 
    tab = 'subjects'
853
 
    permission = 'edit'
854
 
 
855
 
    @property
856
 
    def validator(self):
857
 
        return ProjectSchema()
858
 
 
859
 
    def populate(self, req, ctx):
860
 
        super(ProjectNew, self).populate(req, ctx)
861
 
        ctx['projectset'] = self.context
862
 
 
863
 
    def populate_state(self, state):
864
 
        state.offering = self.context.offering
865
 
        state.existing_project = None
866
 
 
867
 
    def get_default_data(self, req):
868
 
        return {}
869
 
 
870
 
    def save_object(self, req, data):
871
 
        new_project = Project()
872
 
        new_project.project_set = self.context
873
 
        new_project.name = data['name']
874
 
        new_project.short_name = data['short_name']
875
 
        new_project.deadline = data['deadline']
876
 
        new_project.url = unicode(data['url']) if data['url'] else None
877
 
        new_project.synopsis = data['synopsis']
878
 
        req.store.add(new_project)
879
 
        return new_project
880
 
 
881
 
class ProjectDelete(XHTMLView):
882
 
    """A form to delete a project."""
883
 
    template = 'templates/project-delete.html'
884
 
    tab = 'subjects'
885
 
    permission = 'edit'
886
 
 
887
 
    def populate(self, req, ctx):
888
 
        # If post, delete the project, or display a message explaining that
889
 
        # the project cannot be deleted
890
 
        if self.context.can_delete:
891
 
            if req.method == 'POST':
892
 
                self.context.delete()
893
 
                self.template = 'templates/project-deleted.html'
894
 
        else:
895
 
            # Can't delete
896
 
            self.template = 'templates/project-undeletable.html'
897
 
 
898
 
        # If get and can delete, display a delete confirmation page
899
 
 
900
 
        # Variables for the template
901
 
        ctx['req'] = req
902
 
        ctx['project'] = self.context
903
 
        ctx['OfferingProjectsView'] = OfferingProjectsView
904
 
 
905
 
class ProjectSetSchema(formencode.Schema):
906
 
    group_size = formencode.validators.Int(if_missing=None, not_empty=False)
907
 
 
908
 
class ProjectSetEdit(BaseFormView):
909
 
    """A form to edit a project set."""
910
 
    template = 'templates/projectset-edit.html'
911
 
    tab = 'subjects'
912
 
    permission = 'edit'
913
 
 
914
 
    @property
915
 
    def validator(self):
916
 
        return ProjectSetSchema()
917
 
 
918
 
    def populate(self, req, ctx):
919
 
        super(ProjectSetEdit, self).populate(req, ctx)
920
 
 
921
 
    def get_default_data(self, req):
922
 
        return {
923
 
            'group_size': self.context.max_students_per_group,
924
 
            }
925
 
 
926
 
    def save_object(self, req, data):
927
 
        self.context.max_students_per_group = data['group_size']
928
 
        return self.context
929
 
 
930
 
class ProjectSetNew(BaseFormView):
931
 
    """A form to create a new project set."""
932
 
    template = 'templates/projectset-new.html'
933
 
    tab = 'subjects'
934
 
    permission = 'edit'
935
 
    breadcrumb_text = "Projects"
936
 
 
937
 
    @property
938
 
    def validator(self):
939
 
        return ProjectSetSchema()
940
 
 
941
 
    def populate(self, req, ctx):
942
 
        super(ProjectSetNew, self).populate(req, ctx)
943
 
 
944
 
    def get_default_data(self, req):
945
 
        return {}
946
 
 
947
 
    def save_object(self, req, data):
948
 
        new_set = ProjectSet()
949
 
        new_set.offering = self.context
950
 
        new_set.max_students_per_group = data['group_size']
951
 
        req.store.add(new_set)
952
 
        return new_set
 
658
        ctx['format_datetime_short'] = ivle.date.format_datetime_for_paragraph
 
659
        ctx['build_subversion_url'] = self.build_subversion_url
 
660
        ctx['svn_addr'] = req.config['urls']['svn_addr']
 
661
        ctx['project'] = self.context
 
662
        ctx['user'] = req.user
953
663
 
954
664
class Plugin(ViewPlugin, MediaPlugin):
955
665
    forward_routes = (root_to_subject, root_to_semester, subject_to_offering,
956
 
                      offering_to_project, offering_to_projectset,
957
 
                      offering_to_enrolment)
 
666
                      offering_to_project, offering_to_projectset)
958
667
    reverse_routes = (
959
 
        subject_url, semester_url, offering_url, projectset_url, project_url,
960
 
        enrolment_url)
 
668
        subject_url, semester_url, offering_url, projectset_url, project_url)
961
669
 
962
670
    views = [(ApplicationRoot, ('subjects', '+index'), SubjectsView),
963
671
             (ApplicationRoot, ('subjects', '+manage'), SubjectsManage),
964
672
             (ApplicationRoot, ('subjects', '+new'), SubjectNew),
965
673
             (ApplicationRoot, ('subjects', '+new-offering'), OfferingNew),
966
674
             (ApplicationRoot, ('+semesters', '+new'), SemesterNew),
967
 
             (Subject, '+index', SubjectView),
968
675
             (Subject, '+edit', SubjectEdit),
969
 
             (Subject, '+new-offering', SubjectOfferingNew),
970
676
             (Semester, '+edit', SemesterEdit),
971
677
             (Offering, '+index', OfferingView),
972
678
             (Offering, '+edit', OfferingEdit),
973
679
             (Offering, '+clone-worksheets', OfferingCloneWorksheets),
974
680
             (Offering, ('+enrolments', '+index'), EnrolmentsView),
975
681
             (Offering, ('+enrolments', '+new'), EnrolView),
976
 
             (Enrolment, '+edit', EnrolmentEdit),
977
 
             (Enrolment, '+delete', EnrolmentDelete),
978
682
             (Offering, ('+projects', '+index'), OfferingProjectsView),
979
 
             (Offering, ('+projects', '+new-set'), ProjectSetNew),
980
 
             (ProjectSet, '+edit', ProjectSetEdit),
981
 
             (ProjectSet, '+new', ProjectNew),
982
683
             (Project, '+index', ProjectView),
983
 
             (Project, '+edit', ProjectEdit),
984
 
             (Project, '+delete', ProjectDelete),
985
 
             (Project, ('+export', 'project-export.sh'),
986
 
                ProjectBashExportView),
 
684
 
 
685
             (Offering, ('+projectsets', '+new'), OfferingRESTView, 'api'),
 
686
             (ProjectSet, ('+projects', '+new'), ProjectSetRESTView, 'api'),
987
687
             ]
988
688
 
989
689
    breadcrumbs = {Subject: SubjectBreadcrumb,
990
690
                   Offering: OfferingBreadcrumb,
991
691
                   User: UserBreadcrumb,
992
692
                   Project: ProjectBreadcrumb,
993
 
                   Enrolment: EnrolmentBreadcrumb,
994
693
                   }
995
694
 
996
695
    tabs = [