← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ivle/webapp/tutorial/service.py

Created a new help system.

The new help system allows plugins to register their help paths, using
a dict of dicts and helpfile paths. This system allows multiple plugins
to use the same heading for their help files (ie. 'admin').

It also allows XHTMLViews to have a 'help' property, which makes the
context-sensitive help link point to their help path.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/webapp/tutorial/service.py
21
21
 
22
22
import os
23
23
import datetime
24
 
import genshi
25
24
 
26
25
import ivle.util
27
26
import ivle.console
28
27
import ivle.database
29
 
from ivle.database import Exercise, ExerciseAttempt, ExerciseSave, Worksheet, \
30
 
                          Offering, Subject, Semester, WorksheetExercise
31
 
import ivle.worksheet.utils
 
28
import ivle.worksheet
32
29
import ivle.conf
33
30
import ivle.webapp.tutorial.test
34
 
from ivle.webapp.base.rest import (JSONRESTView, named_operation,
35
 
                                   require_permission)
 
31
 
 
32
from ivle.webapp.base.rest import JSONRESTView, named_operation
36
33
from ivle.webapp.errors import NotFound
37
34
 
38
35
# If True, getattempts or getattempt will allow browsing of inactive/disabled
41
38
 
42
39
TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S'
43
40
 
 
41
 
44
42
class AttemptsRESTView(JSONRESTView):
45
43
    '''REST view of a user's attempts at an exercise.'''
46
 
    
47
 
    def __init__(self, req, subject, year, semester, worksheet, 
48
 
                                                exercise, username):
 
44
    def __init__(self, req, subject, worksheet, exercise, username):
 
45
        # TODO: Find exercise within worksheet.
49
46
        self.user = ivle.database.User.get_by_login(req.store, username)
50
47
        if self.user is None:
51
48
            raise NotFound()
52
 
        
53
 
        self.worksheet_exercise = req.store.find(WorksheetExercise,
54
 
            WorksheetExercise.exercise_id == unicode(exercise),
55
 
            WorksheetExercise.worksheet_id == Worksheet.id,
56
 
            Worksheet.offering_id == Offering.id,
57
 
            Worksheet.identifier == unicode(worksheet),
58
 
            Offering.subject_id == Subject.id,
59
 
            Subject.short_name == subject,
60
 
            Offering.semester_id == Semester.id,
61
 
            Semester.year == year,
62
 
            Semester.semester == semester).one()
63
 
        
64
 
        self.context = self.user # XXX: Not quite right.
 
49
        self.exercise = exercise
65
50
 
66
 
    @require_permission('edit')
67
51
    def GET(self, req):
68
52
        """Handles a GET Attempts action."""
69
 
        attempts = req.store.find(ExerciseAttempt, 
70
 
                ExerciseAttempt.ws_ex_id == self.worksheet_exercise.id,
71
 
                ExerciseAttempt.user_id == self.user.id)
 
53
        exercise = ivle.database.Exercise.get_by_name(req.store, 
 
54
                                                        self.exercise)
 
55
 
 
56
        attempts = ivle.worksheet.get_exercise_attempts(req.store, self.user,
 
57
                            exercise, allow_inactive=HISTORY_ALLOW_INACTIVE)
72
58
        # attempts is a list of ExerciseAttempt objects. Convert to dictionaries
73
59
        time_fmt = lambda dt: datetime.datetime.strftime(dt, TIMESTAMP_FORMAT)
74
60
        attempts = [{'date': time_fmt(a.date), 'complete': a.complete}
77
63
        return attempts
78
64
 
79
65
 
80
 
    @require_permission('edit')
81
66
    def PUT(self, req, data):
82
 
        """ Tests the given submission """
83
 
        exercise = req.store.find(Exercise, 
84
 
            Exercise.id == self.worksheet_exercise.exercise_id).one()
85
 
        if exercise is None:
 
67
        ''' Tests the given submission '''
 
68
        exercisefile = ivle.util.open_exercise_file(self.exercise)
 
69
        if exercisefile is None:
86
70
            raise NotFound()
87
71
 
88
72
        # Start a console to run the tests on
92
76
 
93
77
        # Parse the file into a exercise object using the test suite
94
78
        exercise_obj = ivle.webapp.tutorial.test.parse_exercise_file(
95
 
                                                            exercise, cons)
 
79
                                                            exercisefile, cons)
 
80
        exercisefile.close()
96
81
 
97
82
        # Run the test cases. Get the result back as a JSONable object.
98
83
        # Return it.
101
86
        # Close the console
102
87
        cons.close()
103
88
 
 
89
        # Get the Exercise from the database
 
90
        exercise = ivle.database.Exercise.get_by_name(req.store, self.exercise)
 
91
 
104
92
        attempt = ivle.database.ExerciseAttempt(user=req.user,
105
 
            worksheet_exercise = self.worksheet_exercise,
106
 
            date = datetime.datetime.now(),
107
 
            complete = test_results['passed'],
108
 
            text = unicode(data['code'])
109
 
        )
 
93
                                                exercise=exercise,
 
94
                                                date=datetime.datetime.now(),
 
95
                                                complete=test_results['passed'],
 
96
                                                # XXX
 
97
                                                text=unicode(data['code']))
110
98
 
111
99
        req.store.add(attempt)
112
100
 
113
101
        # Query the DB to get an updated score on whether or not this problem
114
102
        # has EVER been completed (may be different from "passed", if it has
115
103
        # been completed before), and the total number of attempts.
116
 
        completed, attempts = ivle.worksheet.utils.get_exercise_status(
117
 
                req.store, req.user, self.worksheet_exercise)
 
104
        completed, attempts = ivle.worksheet.get_exercise_status(req.store,
 
105
            req.user, exercise)
118
106
        test_results["completed"] = completed
119
107
        test_results["attempts"] = attempts
120
108
 
124
112
class AttemptRESTView(JSONRESTView):
125
113
    '''REST view of an exercise attempt.'''
126
114
 
127
 
    def __init__(self, req, subject, year, semester, worksheet, exercise, 
128
 
                 username, date):
 
115
    def __init__(self, req, subject, worksheet, exercise, username, date):
129
116
        # TODO: Find exercise within worksheet.
130
117
        user = ivle.database.User.get_by_login(req.store, username)
131
118
        if user is None:
136
123
        except ValueError:
137
124
            raise NotFound()
138
125
 
139
 
        # XXX Hack around Google Code issue #87
140
 
        # Query from the given date +1 secnod.
141
 
        # Date is in seconds (eg. 3:47:12), while the data is in finer time
142
 
        # (eg. 3:47:12.3625). The query "date <= 3:47:12" will fail because
143
 
        # 3:47:12.3625 is greater. Hence we do the query from +1 second,
144
 
        # "date <= 3:47:13", and it finds the correct submission, UNLESS there
145
 
        # are multiple submissions inside the same second.
146
 
        date += datetime.timedelta(seconds=1)
147
 
 
148
 
        worksheet_exercise = req.store.find(WorksheetExercise,
149
 
            WorksheetExercise.exercise_id == exercise,
150
 
            WorksheetExercise.worksheet_id == Worksheet.id,
151
 
            Worksheet.identifier == worksheet,
152
 
            Worksheet.offering_id == Offering.id,
153
 
            Offering.subject_id == Subject.id,
154
 
            Subject.short_name == subject,
155
 
            Offering.semester_id == Semester.id,
156
 
            Semester.year == year,
157
 
            Semester.semester == semester).one()
158
 
            
159
 
        attempt = ivle.worksheet.utils.get_exercise_attempt(req.store, user,
160
 
                        worksheet_exercise, as_of=date,
161
 
                        allow_inactive=HISTORY_ALLOW_INACTIVE) 
 
126
        exercise = ivle.database.Exercise.get_by_name(req.store, exercise)
 
127
        attempt = ivle.worksheet.get_exercise_attempt(req.store, user,
 
128
            exercise, as_of=date, allow_inactive=HISTORY_ALLOW_INACTIVE)
162
129
 
163
130
        if attempt is None:
164
131
            raise NotFound()
165
132
 
166
133
        self.context = attempt
167
134
 
168
 
    @require_permission('view')
169
135
    def GET(self, req):
170
136
        return {'code': self.context.text}
171
137
 
172
138
 
173
 
class WorksheetExerciseRESTView(JSONRESTView):
174
 
    '''REST view of a worksheet exercise.'''
175
 
 
176
 
    def __init__(self, req, subject, year, semester, worksheet, exercise):
177
 
        self.context = req.store.find(WorksheetExercise,
178
 
            WorksheetExercise.exercise_id == exercise,
179
 
            WorksheetExercise.worksheet_id == Worksheet.id,
180
 
            Worksheet.offering_id == Offering.id,
181
 
            Offering.subject_id == Subject.id,
182
 
            Subject.short_name == subject,
183
 
            Offering.semester_id == Semester.id,
184
 
            Semester.year == year,
185
 
            Semester.semester == semester).one()
186
 
        
187
 
        if self.context is None:
188
 
            raise NotFound()
189
 
 
190
 
    @named_operation('view')
 
139
class ExerciseRESTView(JSONRESTView):
 
140
    '''REST view of an exercise.'''
 
141
    @named_operation
191
142
    def save(self, req, text):
192
 
        # Find the appropriate WorksheetExercise to save to. If its not found,
193
 
        # the user is submitting against a non-existant worksheet/exercise
194
 
 
195
 
        old_save = req.store.find(ExerciseSave,
196
 
            ExerciseSave.ws_ex_id == self.context.id,
197
 
            ExerciseSave.user == req.user).one()
198
 
        
199
 
        #Overwrite the old, or create a new if there isn't one
200
 
        if old_save is None:
201
 
            new_save = ExerciseSave()
202
 
            req.store.add(new_save)
203
 
        else:
204
 
            new_save = old_save
205
 
        
206
 
        new_save.worksheet_exercise = self.context
207
 
        new_save.user = req.user
208
 
        new_save.text = unicode(text)
209
 
        new_save.date = datetime.datetime.now()
210
 
 
211
 
        return {"result": "ok"}
212
 
 
213
 
 
214
 
# Note that this is the view of an existing worksheet. Creation is handled
215
 
# by OfferingRESTView (as offerings have worksheets)
216
 
class WorksheetRESTView(JSONRESTView):
217
 
    """View used to update a worksheet."""
218
 
 
219
 
    def __init__(self, req, **kwargs):
220
 
    
221
 
        self.worksheet = kwargs['worksheet']
222
 
        self.subject = kwargs['subject']
223
 
        self.year = kwargs['year']
224
 
        self.semester = kwargs['semester']
225
 
    
226
 
        self.context = req.store.find(Worksheet,
227
 
            Worksheet.identifier == self.worksheet,
228
 
            Worksheet.offering_id == Offering.id,
229
 
            Offering.subject_id == Subject.id,
230
 
            Subject.short_name == self.subject,
231
 
            Offering.semester_id == Semester.id,
232
 
            Semester.year == self.year,
233
 
            Semester.semester == self.semester).one()
234
 
        
235
 
        if self.context is None:
236
 
            raise NotFound()
237
 
    
238
 
    @named_operation('edit')
239
 
    def save(self, req, name, assessable, data, format):
240
 
        """Takes worksheet data and saves it."""
241
 
        self.context.name = unicode(name)
242
 
        self.context.assessable = self.convert_bool(assessable)
243
 
        self.context.data = unicode(data)
244
 
        self.context.format = unicode(format)
245
 
        ivle.worksheet.utils.update_exerciselist(self.context)
246
 
        
247
 
        return {"result": "ok"}
248
 
 
249
 
class WorksheetsRESTView(JSONRESTView):
250
 
    """View used to update and create Worksheets."""
251
 
    
252
 
    def __init__(self, req, **kwargs):
253
 
    
254
 
        self.subject = kwargs['subject']
255
 
        self.year = kwargs['year']
256
 
        self.semester = kwargs['semester']
257
 
    
258
 
        self.context = req.store.find(Offering,
259
 
            Offering.subject_id == Subject.id,
260
 
            Subject.short_name == self.subject,
261
 
            Offering.semester_id == Semester.id,
262
 
            Semester.year == self.year,
263
 
            Semester.semester == self.semester).one()
264
 
        
265
 
        if self.context is None:
266
 
            raise NotFound()
267
 
 
268
 
    @named_operation('edit')
269
 
    def add_worksheet(self, req, identifier, name, assessable, data, format):
270
 
        """Takes worksheet data and adds it."""
271
 
        
272
 
        new_worksheet = Worksheet()
273
 
        new_worksheet.seq_no = self.context.worksheets.count()
274
 
        # Setting new_worksheet.offering implicitly adds new_worksheet,
275
 
        # hence worksheets.count MUST be called above it
276
 
        new_worksheet.offering = self.context
277
 
        new_worksheet.identifier = unicode(identifier)
278
 
        new_worksheet.name = unicode(name)
279
 
        new_worksheet.assessable = self.convert_bool(assessable)
280
 
        new_worksheet.data = unicode(data)
281
 
        new_worksheet.format = unicode(format)
282
 
        
283
 
        # This call is added for clarity, as the worksheet is implicitly added.        
284
 
        req.store.add(new_worksheet)
285
 
 
286
 
        ivle.worksheet.utils.update_exerciselist(new_worksheet)
287
 
 
288
 
        return {"result": "ok"}
289
 
 
290
 
    @named_operation('edit')
291
 
    def move_up(self, req, worksheetid):
292
 
        """Takes a list of worksheet-seq_no pairs and updates their 
293
 
        corresponding Worksheet objects to match."""
294
 
        
295
 
        worksheet_below = req.store.find(Worksheet,
296
 
            Worksheet.offering_id == self.context.id,
297
 
            Worksheet.identifier == unicode(worksheetid)).one()
298
 
        if worksheet_below is None:
299
 
            raise NotFound('worksheet_below')
300
 
        worksheet_above = req.store.find(Worksheet,
301
 
            Worksheet.offering_id == self.context.id,
302
 
            Worksheet.seq_no == (worksheet_below.seq_no - 1)).one()
303
 
        if worksheet_above is None:
304
 
            raise NotFound('worksheet_above')
305
 
 
306
 
        worksheet_below.seq_no = worksheet_below.seq_no - 1
307
 
        worksheet_above.seq_no = worksheet_above.seq_no + 1
308
 
        
309
 
        return {'result': 'ok'}
310
 
 
311
 
    @named_operation('edit')
312
 
    def move_down(self, req, worksheetid):
313
 
        """Takes a list of worksheet-seq_no pairs and updates their 
314
 
        corresponding Worksheet objects to match."""
315
 
        
316
 
        worksheet_above = req.store.find(Worksheet,
317
 
            Worksheet.offering_id == self.context.id,
318
 
            Worksheet.identifier == unicode(worksheetid)).one()
319
 
        if worksheet_above is None:
320
 
            raise NotFound('worksheet_below')
321
 
        worksheet_below = req.store.find(Worksheet,
322
 
            Worksheet.offering_id == self.context.id,
323
 
            Worksheet.seq_no == (worksheet_above.seq_no + 1)).one()
324
 
        if worksheet_below is None:
325
 
            raise NotFound('worksheet_above')
326
 
 
327
 
        worksheet_below.seq_no = worksheet_below.seq_no - 1
328
 
        worksheet_above.seq_no = worksheet_above.seq_no + 1
329
 
        
330
 
        return {'result': 'ok'}
 
143
        # Need to open JUST so we know this is a real exercise.
 
144
        # (This avoids users submitting code for bogus exercises).
 
145
        exercisefile = ivle.util.open_exercise_file(self.exercise)
 
146
        if exercisefile is None:
 
147
            raise NotFound()
 
148
        exercisefile.close()
 
149
 
 
150
        exercise = ivle.database.Exercise.get_by_name(req.store, self.exercise)
 
151
        ivle.worksheet.save_exercise(req.store, req.user, exercise,
 
152
                                     unicode(text), datetime.datetime.now())
 
153
        return {"result": "ok"}