← 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

  • Committer: William Grant
  • Date: 2009-02-25 23:04:11 UTC
  • Revision ID: grantw@unimelb.edu.au-20090225230411-lbdyl32ir0m3d59b
Make all of the services executable.

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
24
25
 
25
26
import ivle.util
26
27
import ivle.console
27
28
import ivle.database
28
 
from ivle.database import Exercise, ExerciseAttempt, ExerciseSave, Worksheet, Offering, Subject, Semester
 
29
from ivle.database import Exercise, ExerciseAttempt, ExerciseSave, Worksheet, \
 
30
                          Offering, Subject, Semester, WorksheetExercise
29
31
import ivle.worksheet
30
32
import ivle.conf
31
33
import ivle.webapp.tutorial.test
40
42
 
41
43
TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S'
42
44
 
43
 
 
44
45
class AttemptsRESTView(JSONRESTView):
45
46
    '''REST view of a user's attempts at an exercise.'''
 
47
    
46
48
    def __init__(self, req, subject, year, semester, worksheet, 
47
49
                                                exercise, username):
48
50
        self.user = ivle.database.User.get_by_login(req.store, username)
49
51
        if self.user is None:
50
52
            raise NotFound()
51
 
        self.exercise = exercise
52
53
        
53
 
        self.worksheet = req.store.find(Worksheet,
54
 
            Worksheet.name == worksheet,
 
54
        self.worksheet_exercise = req.store.find(WorksheetExercise,
 
55
            WorksheetExercise.exercise_id == exercise,
 
56
            WorksheetExercise.worksheet_id == Worksheet.id,
55
57
            Worksheet.offering_id == Offering.id,
56
58
            Offering.subject_id == Subject.id,
57
59
            Subject.code == subject,
64
66
    @require_permission('edit')
65
67
    def GET(self, req):
66
68
        """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.exercise_id == exercise.id,
 
70
                ExerciseAttempt.ws_ex_id == self.worksheet_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, Exercise.id == self.exercise).one()
 
83
        exercise = req.store.find(Exercise, 
 
84
            Exercise.id == self.worksheet_exercise.exercise_id).one()
84
85
        if exercise is None:
85
86
            raise NotFound()
86
87
 
101
102
        cons.close()
102
103
 
103
104
        attempt = ivle.database.ExerciseAttempt(user=req.user,
104
 
                                                exercise=exercise,
105
 
                                                date=datetime.datetime.now(),
106
 
                                                complete=test_results['passed'],
107
 
                                                worksheet=self.worksheet,
108
 
                                                text=unicode(data['code']))
 
105
            worksheet_exercise = self.worksheet_exercise,
 
106
            date = datetime.datetime.now(),
 
107
            complete = test_results['passed'],
 
108
            text = unicode(data['code'])
 
109
        )
109
110
 
110
111
        req.store.add(attempt)
111
112
 
113
114
        # has EVER been completed (may be different from "passed", if it has
114
115
        # been completed before), and the total number of attempts.
115
116
        completed, attempts = ivle.worksheet.get_exercise_status(req.store,
116
 
            req.user, exercise, self.worksheet)
 
117
            req.user, self.worksheet_exercise)
117
118
        test_results["completed"] = completed
118
119
        test_results["attempts"] = attempts
119
120
 
123
124
class AttemptRESTView(JSONRESTView):
124
125
    '''REST view of an exercise attempt.'''
125
126
 
126
 
    def __init__(self, req, subject, worksheet, exercise, username, date):
 
127
    def __init__(self, req, subject, year, semester, worksheet, exercise, 
 
128
                 username, date):
127
129
        # TODO: Find exercise within worksheet.
128
130
        user = ivle.database.User.get_by_login(req.store, username)
129
131
        if user is None:
134
136
        except ValueError:
135
137
            raise NotFound()
136
138
 
137
 
        exercise = ivle.database.Exercise.get_by_name(req.store, exercise)
138
 
        worksheet = req.store.find(Worksheet,
139
 
            Worksheet.name == self.worksheet,
 
139
        worksheet_exercise = req.store.find(WorksheetExercise,
 
140
            WorksheetExercise.exercise_id == exercise,
 
141
            WorksheetExercise.worksheet_id == Worksheet.id,
 
142
            Worksheet.identifier == worksheet,
140
143
            Worksheet.offering_id == Offering.id,
141
144
            Offering.subject_id == Subject.id,
142
 
            Subject.code == self.subject,
 
145
            Subject.code == subject,
143
146
            Offering.semester_id == Semester.id,
144
 
            Semester.year == self.year,
145
 
            Semester.semester == self.semester).one()
146
 
 
 
147
            Semester.year == year,
 
148
            Semester.semester == semester).one()
 
149
            
147
150
        attempt = ivle.worksheet.get_exercise_attempt(req.store, user,
148
 
            exercise, worksheet, as_of=date, allow_inactive=HISTORY_ALLOW_INACTIVE)
 
151
                        worksheet_exercise, as_of=date,
 
152
                        allow_inactive=HISTORY_ALLOW_INACTIVE) 
149
153
 
150
154
        if attempt is None:
151
155
            raise NotFound()
162
166
 
163
167
    def get_permissions(self, user):
164
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?
165
171
        if user is not None:
166
172
            return set(['save'])
167
173
        else:
169
175
 
170
176
    @named_operation('save')
171
177
    def save(self, req, text):
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"}
 
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'}