← 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

Update some docs, and remove other obsolete ones.

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
 
28
from ivle.database import Exercise, ExerciseAttempt, ExerciseSave, Worksheet, Offering, Subject, Semester
31
29
import ivle.worksheet
32
30
import ivle.conf
33
31
import ivle.webapp.tutorial.test
42
40
 
43
41
TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S'
44
42
 
 
43
 
45
44
class AttemptsRESTView(JSONRESTView):
46
45
    '''REST view of a user's attempts at an exercise.'''
47
 
    
48
46
    def __init__(self, req, subject, year, semester, worksheet, 
49
47
                                                exercise, username):
50
48
        self.user = ivle.database.User.get_by_login(req.store, username)
51
49
        if self.user is None:
52
50
            raise NotFound()
 
51
        self.exercise = exercise
53
52
        
54
 
        self.worksheet_exercise = req.store.find(WorksheetExercise,
55
 
            WorksheetExercise.exercise_id == exercise,
56
 
            WorksheetExercise.worksheet_id == Worksheet.id,
 
53
        self.worksheet = req.store.find(Worksheet,
 
54
            Worksheet.name == worksheet,
57
55
            Worksheet.offering_id == Offering.id,
58
56
            Offering.subject_id == Subject.id,
59
57
            Subject.code == subject,
66
64
    @require_permission('edit')
67
65
    def GET(self, req):
68
66
        """Handles a GET Attempts action."""
 
67
        exercise = req.store.find(Exercise, Exercise.id == self.exercise).one()
 
68
 
69
69
        attempts = req.store.find(ExerciseAttempt, 
70
 
                ExerciseAttempt.ws_ex_id == self.worksheet_exercise.id,
 
70
                ExerciseAttempt.exercise_id == exercise.id,
71
71
                ExerciseAttempt.user_id == self.user.id)
72
72
        # attempts is a list of ExerciseAttempt objects. Convert to dictionaries
73
73
        time_fmt = lambda dt: datetime.datetime.strftime(dt, TIMESTAMP_FORMAT)
80
80
    @require_permission('edit')
81
81
    def PUT(self, req, data):
82
82
        """ Tests the given submission """
83
 
        exercise = req.store.find(Exercise, 
84
 
            Exercise.id == self.worksheet_exercise.exercise_id).one()
 
83
        exercise = req.store.find(Exercise, Exercise.id == self.exercise).one()
85
84
        if exercise is None:
86
85
            raise NotFound()
87
86
 
102
101
        cons.close()
103
102
 
104
103
        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
 
        )
 
104
                                                exercise=exercise,
 
105
                                                date=datetime.datetime.now(),
 
106
                                                complete=test_results['passed'],
 
107
                                                worksheet=self.worksheet,
 
108
                                                text=unicode(data['code']))
110
109
 
111
110
        req.store.add(attempt)
112
111
 
114
113
        # has EVER been completed (may be different from "passed", if it has
115
114
        # been completed before), and the total number of attempts.
116
115
        completed, attempts = ivle.worksheet.get_exercise_status(req.store,
117
 
            req.user, self.worksheet_exercise)
 
116
            req.user, exercise, self.worksheet)
118
117
        test_results["completed"] = completed
119
118
        test_results["attempts"] = attempts
120
119
 
124
123
class AttemptRESTView(JSONRESTView):
125
124
    '''REST view of an exercise attempt.'''
126
125
 
127
 
    def __init__(self, req, subject, year, semester, worksheet, exercise, 
128
 
                 username, date):
 
126
    def __init__(self, req, subject, worksheet, exercise, username, date):
129
127
        # TODO: Find exercise within worksheet.
130
128
        user = ivle.database.User.get_by_login(req.store, username)
131
129
        if user is None:
136
134
        except ValueError:
137
135
            raise NotFound()
138
136
 
139
 
        worksheet_exercise = req.store.find(WorksheetExercise,
140
 
            WorksheetExercise.exercise_id == exercise,
141
 
            WorksheetExercise.worksheet_id == Worksheet.id,
142
 
            Worksheet.identifier == worksheet,
 
137
        exercise = ivle.database.Exercise.get_by_name(req.store, exercise)
 
138
        worksheet = req.store.find(Worksheet,
 
139
            Worksheet.name == self.worksheet,
143
140
            Worksheet.offering_id == Offering.id,
144
141
            Offering.subject_id == Subject.id,
145
 
            Subject.code == subject,
 
142
            Subject.code == self.subject,
146
143
            Offering.semester_id == Semester.id,
147
 
            Semester.year == year,
148
 
            Semester.semester == semester).one()
149
 
            
 
144
            Semester.year == self.year,
 
145
            Semester.semester == self.semester).one()
 
146
 
150
147
        attempt = ivle.worksheet.get_exercise_attempt(req.store, user,
151
 
                        worksheet_exercise, as_of=date,
152
 
                        allow_inactive=HISTORY_ALLOW_INACTIVE) 
 
148
            exercise, worksheet, as_of=date, allow_inactive=HISTORY_ALLOW_INACTIVE)
153
149
 
154
150
        if attempt is None:
155
151
            raise NotFound()
166
162
 
167
163
    def get_permissions(self, user):
168
164
        # 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
165
        if user is not None:
172
166
            return set(['save'])
173
167
        else:
175
169
 
176
170
    @named_operation('save')
177
171
    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'}
 
172
        # Need to open JUST so we know this is a real exercise.
 
173
        # (This avoids users submitting code for bogus exercises).
 
174
        exercise = req.store.find(Exercise,
 
175
            Exercise.id == self.exercise).one()
 
176
        worksheet = req.store.find(Worksheet,
 
177
            Worksheet.name == self.worksheet,
 
178
            Worksheet.offering_id == Offering.id,
 
179
            Offering.subject_id == Subject.id,
 
180
            Subject.code == self.subject,
 
181
            Offering.semester_id == Semester.id,
 
182
            Semester.year == self.year,
 
183
            Semester.semester == self.semester).one()
 
184
        ivle.worksheet.save_exercise(req.store, req.user, exercise, worksheet,
 
185
                                     unicode(text), datetime.datetime.now())
 
186
        return {"result": "ok"}