← 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

Fix the help ToC's title and list nesting.

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
28
import ivle.worksheet
32
29
import ivle.conf
33
30
import ivle.webapp.tutorial.test
34
31
 
35
 
from ivle.webapp.base.rest import (JSONRESTView, named_operation,
36
 
                                   require_permission)
 
32
from ivle.webapp.base.rest import JSONRESTView, named_operation
37
33
from ivle.webapp.errors import NotFound
38
34
 
39
35
# If True, getattempts or getattempt will allow browsing of inactive/disabled
42
38
 
43
39
TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S'
44
40
 
 
41
 
45
42
class AttemptsRESTView(JSONRESTView):
46
43
    '''REST view of a user's attempts at an exercise.'''
47
 
    
48
 
    def __init__(self, req, subject, year, semester, worksheet, 
49
 
                                                exercise, username):
 
44
    def __init__(self, req, subject, worksheet, exercise, username):
 
45
        # TODO: Find exercise within worksheet.
50
46
        self.user = ivle.database.User.get_by_login(req.store, username)
51
47
        if self.user is None:
52
48
            raise NotFound()
53
 
        
54
 
        self.worksheet_exercise = req.store.find(WorksheetExercise,
55
 
            WorksheetExercise.exercise_id == exercise,
56
 
            WorksheetExercise.worksheet_id == Worksheet.id,
57
 
            Worksheet.offering_id == Offering.id,
58
 
            Offering.subject_id == Subject.id,
59
 
            Subject.code == 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
 
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
104
        completed, attempts = ivle.worksheet.get_exercise_status(req.store,
117
 
            req.user, self.worksheet_exercise)
 
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
 
        worksheet_exercise = req.store.find(WorksheetExercise,
140
 
            WorksheetExercise.exercise_id == exercise,
141
 
            WorksheetExercise.worksheet_id == Worksheet.id,
142
 
            Worksheet.identifier == worksheet,
143
 
            Worksheet.offering_id == Offering.id,
144
 
            Offering.subject_id == Subject.id,
145
 
            Subject.code == subject,
146
 
            Offering.semester_id == Semester.id,
147
 
            Semester.year == year,
148
 
            Semester.semester == semester).one()
149
 
            
 
126
        exercise = ivle.database.Exercise.get_by_name(req.store, exercise)
150
127
        attempt = ivle.worksheet.get_exercise_attempt(req.store, user,
151
 
                        worksheet_exercise, as_of=date,
152
 
                        allow_inactive=HISTORY_ALLOW_INACTIVE) 
 
128
            exercise, as_of=date, allow_inactive=HISTORY_ALLOW_INACTIVE)
153
129
 
154
130
        if attempt is None:
155
131
            raise NotFound()
156
132
 
157
133
        self.context = attempt
158
134
 
159
 
    @require_permission('view')
160
135
    def GET(self, req):
161
136
        return {'code': self.context.text}
162
137
 
163
138
 
164
139
class ExerciseRESTView(JSONRESTView):
165
140
    '''REST view of an exercise.'''
166
 
 
167
 
    def get_permissions(self, user):
168
 
        # XXX: Do it properly.
169
 
        # XXX: Does any user have the ability to save as themselves?
170
 
        # XXX: Does a user EVER have permission to save as another user?
171
 
        if user is not None:
172
 
            return set(['save'])
173
 
        else:
174
 
            return set()
175
 
 
176
 
    @named_operation('save')
 
141
    @named_operation
177
142
    def save(self, req, text):
178
 
        # Find the appropriate WorksheetExercise to save to. If its not found,
179
 
        # the user is submitting against a non-existant worksheet/exercise
180
 
        worksheet_exercise = req.store.find(WorksheetExercise,
181
 
            WorksheetExercise.exercise_id == self.exercise,
182
 
            WorksheetExercise.worksheet_id == Worksheet.id,
183
 
            Worksheet.offering_id == Offering.id,
184
 
            Offering.subject_id == Subject.id,
185
 
            Subject.code == self.subject,
186
 
            Offering.semester_id == Semester.id,
187
 
            Semester.year == self.year,
188
 
            Semester.semester == self.semester).one()
189
 
        
190
 
        if worksheet_exercise is None:
191
 
            raise NotFound()
192
 
 
193
 
        old_save = req.store.find(ExerciseSave,
194
 
            ExerciseSave.ws_ex_id == worksheet_exercise.id,
195
 
            ExerciseSave.user == req.user).one()
196
 
        
197
 
        #Overwrite the old, or create a new if there isn't one
198
 
        if old_save is None:
199
 
            new_save = ExerciseSave()
200
 
            req.store.add(new_save)
201
 
        else:
202
 
            new_save = old_save
203
 
        
204
 
        new_save.worksheet_exercise = worksheet_exercise
205
 
        new_save.user = req.user
206
 
        new_save.text = unicode(text)
207
 
        new_save.date = datetime.datetime.now()
208
 
 
209
 
        return {"result": "ok"}
210
 
 
211
 
 
212
 
 
213
 
# Note that this is the view of an existing worksheet. Creation is handled
214
 
# by OfferingRESTView (as offerings have worksheets)
215
 
class WorksheetRESTView(JSONRESTView):
216
 
    """View used to update a worksheet."""
217
 
 
218
 
    def get_permissions(self, user):
219
 
        # XXX: Do it properly.
220
 
        # XXX: Lecturers should be allowed to add worksheets Only to subjects
221
 
        #      under their control
222
 
        if user is not None:
223
 
            if user.admin:
224
 
                return set(['save'])
225
 
            else:
226
 
                return set()
227
 
        else:
228
 
            return set()    
229
 
 
230
 
    def __init__(self, req, **kwargs):
231
 
    
232
 
        self.worksheet = kwargs['worksheet']
233
 
        self.subject = kwargs['subject']
234
 
        self.year = kwargs['year']
235
 
        self.semester = kwargs['semester']
236
 
    
237
 
        self.context = req.store.find(Worksheet,
238
 
            Worksheet.identifier == self.worksheet,
239
 
            Worksheet.offering_id == Offering.id,
240
 
            Offering.subject_id == Subject.id,
241
 
            Subject.code == self.subject,
242
 
            Offering.semester_id == Semester.id,
243
 
            Semester.year == self.year,
244
 
            Semester.semester == self.semester).one()
245
 
        
246
 
        if self.context is None:
247
 
            raise NotFound()
248
 
    
249
 
    @named_operation('save')
250
 
    def save(self, req, name, assessable, data, format):
251
 
        """Takes worksheet data and saves it."""
252
 
        self.context.name = unicode(name)
253
 
        self.context.assessable = self.convert_bool(assessable)
254
 
        self.context.data = unicode(data)
255
 
        self.context.format = unicode(format)
256
 
        ivle.worksheet.update_exerciselist(self.context)
257
 
        
258
 
        return {"result": "ok"}
259
 
 
260
 
class WorksheetsRESTView(JSONRESTView):
261
 
    """View used to update and create Worksheets."""
262
 
    
263
 
    def get_permissions(self, user):
264
 
        # XXX: Do it properly.
265
 
        # XXX: Lecturers should be allowed to add worksheets Only to subjects
266
 
        #      under their control
267
 
        if user is not None:
268
 
            if user.admin:
269
 
                return set(['edit'])
270
 
            else:
271
 
                return set()
272
 
        else:
273
 
            return set()
274
 
 
275
 
    def __init__(self, req, **kwargs):
276
 
    
277
 
        self.subject = kwargs['subject']
278
 
        self.year = kwargs['year']
279
 
        self.semester = kwargs['semester']
280
 
    
281
 
        self.context = req.store.find(Offering,
282
 
            Offering.subject_id == Subject.id,
283
 
            Subject.code == self.subject,
284
 
            Offering.semester_id == Semester.id,
285
 
            Semester.year == self.year,
286
 
            Semester.semester == self.semester).one()
287
 
        
288
 
        if self.context is None:
289
 
            raise NotFound()
290
 
 
291
 
    @named_operation('edit')
292
 
    def add_worksheet(self, req, identifier, name, assessable, data, format):
293
 
        """Takes worksheet data and adds it."""
294
 
        
295
 
        new_worksheet = Worksheet()
296
 
        new_worksheet.seq_no = self.context.worksheets.count()
297
 
        # Setting new_worksheet.offering implicitly adds new_worksheet,
298
 
        # hence worksheets.count MUST be called above it
299
 
        new_worksheet.offering = self.context
300
 
        new_worksheet.identifier = unicode(identifier)
301
 
        new_worksheet.name = unicode(name)
302
 
        new_worksheet.assessable = self.convert_bool(assessable)
303
 
        new_worksheet.data = unicode(data)
304
 
        new_worksheet.format = unicode(format)
305
 
        
306
 
        # This call is added for clarity, as the worksheet is implicitly added.        
307
 
        req.store.add(new_worksheet)
308
 
        
309
 
        ivle.worksheet.update_exerciselist(new_worksheet)
310
 
        
311
 
        return {"result": "ok"}
312
 
 
313
 
    @named_operation('edit')
314
 
    def move_up(self, req, worksheetid):
315
 
        """Takes a list of worksheet-seq_no pairs and updates their 
316
 
        corresponding Worksheet objects to match."""
317
 
        
318
 
        worksheet_below = req.store.find(Worksheet,
319
 
            Worksheet.offering_id == self.context.id,
320
 
            Worksheet.identifier == unicode(worksheetid)).one()
321
 
        if worksheet_below is None:
322
 
            raise NotFound('worksheet_below')
323
 
        worksheet_above = req.store.find(Worksheet,
324
 
            Worksheet.offering_id == self.context.id,
325
 
            Worksheet.seq_no == (worksheet_below.seq_no - 1)).one()
326
 
        if worksheet_above is None:
327
 
            raise NotFound('worksheet_above')
328
 
 
329
 
        worksheet_below.seq_no = worksheet_below.seq_no - 1
330
 
        worksheet_above.seq_no = worksheet_above.seq_no + 1
331
 
        
332
 
        return {'result': 'ok'}
333
 
 
334
 
    @named_operation('edit')
335
 
    def move_down(self, req, worksheetid):
336
 
        """Takes a list of worksheet-seq_no pairs and updates their 
337
 
        corresponding Worksheet objects to match."""
338
 
        
339
 
        worksheet_above = req.store.find(Worksheet,
340
 
            Worksheet.offering_id == self.context.id,
341
 
            Worksheet.identifier == unicode(worksheetid)).one()
342
 
        if worksheet_above is None:
343
 
            raise NotFound('worksheet_below')
344
 
        worksheet_below = req.store.find(Worksheet,
345
 
            Worksheet.offering_id == self.context.id,
346
 
            Worksheet.seq_no == (worksheet_above.seq_no + 1)).one()
347
 
        if worksheet_below is None:
348
 
            raise NotFound('worksheet_above')
349
 
 
350
 
        worksheet_below.seq_no = worksheet_below.seq_no - 1
351
 
        worksheet_above.seq_no = worksheet_above.seq_no + 1
352
 
        
353
 
        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"}