← 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-27 05:07:09 UTC
  • Revision ID: grantw@unimelb.edu.au-20090227050709-k16kvhyl50nzjbwm
Subject URLs now contain the short name (eg. info1) rather than the code
(eg. 600151).

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
 
            Subject.code == subject,
 
59
            Subject.short_name == subject,
58
60
            Offering.semester_id == Semester.id,
59
61
            Semester.year == year,
60
62
            Semester.semester == semester).one()
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
        # 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,
140
152
            Worksheet.offering_id == Offering.id,
141
153
            Offering.subject_id == Subject.id,
142
 
            Subject.code == self.subject,
 
154
            Subject.short_name == subject,
143
155
            Offering.semester_id == Semester.id,
144
 
            Semester.year == self.year,
145
 
            Semester.semester == self.semester).one()
146
 
 
 
156
            Semester.year == year,
 
157
            Semester.semester == semester).one()
 
158
            
147
159
        attempt = ivle.worksheet.get_exercise_attempt(req.store, user,
148
 
            exercise, worksheet, as_of=date, allow_inactive=HISTORY_ALLOW_INACTIVE)
 
160
                        worksheet_exercise, as_of=date,
 
161
                        allow_inactive=HISTORY_ALLOW_INACTIVE) 
149
162
 
150
163
        if attempt is None:
151
164
            raise NotFound()
157
170
        return {'code': self.context.text}
158
171
 
159
172
 
160
 
class ExerciseRESTView(JSONRESTView):
161
 
    '''REST view of an exercise.'''
162
 
 
163
 
    def get_permissions(self, user):
164
 
        # XXX: Do it properly.
165
 
        if user is not None:
166
 
            return set(['save'])
 
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')
 
191
    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)
167
203
        else:
168
 
            return set()
169
 
 
170
 
    @named_operation('save')
171
 
    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,
 
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
 
 
215
# Note that this is the view of an existing worksheet. Creation is handled
 
216
# by OfferingRESTView (as offerings have worksheets)
 
217
class WorksheetRESTView(JSONRESTView):
 
218
    """View used to update a worksheet."""
 
219
 
 
220
    def __init__(self, req, **kwargs):
 
221
    
 
222
        self.worksheet = kwargs['worksheet']
 
223
        self.subject = kwargs['subject']
 
224
        self.year = kwargs['year']
 
225
        self.semester = kwargs['semester']
 
226
    
 
227
        self.context = req.store.find(Worksheet,
 
228
            Worksheet.identifier == self.worksheet,
178
229
            Worksheet.offering_id == Offering.id,
179
230
            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"}
 
231
            Subject.short_name == self.subject,
 
232
            Offering.semester_id == Semester.id,
 
233
            Semester.year == self.year,
 
234
            Semester.semester == self.semester).one()
 
235
        
 
236
        if self.context is None:
 
237
            raise NotFound()
 
238
    
 
239
    @named_operation('edit')
 
240
    def save(self, req, name, assessable, data, format):
 
241
        """Takes worksheet data and saves it."""
 
242
        self.context.name = unicode(name)
 
243
        self.context.assessable = self.convert_bool(assessable)
 
244
        self.context.data = unicode(data)
 
245
        self.context.format = unicode(format)
 
246
        ivle.worksheet.update_exerciselist(self.context)
 
247
        
 
248
        return {"result": "ok"}
 
249
 
 
250
class WorksheetsRESTView(JSONRESTView):
 
251
    """View used to update and create Worksheets."""
 
252
    
 
253
    def __init__(self, req, **kwargs):
 
254
    
 
255
        self.subject = kwargs['subject']
 
256
        self.year = kwargs['year']
 
257
        self.semester = kwargs['semester']
 
258
    
 
259
        self.context = req.store.find(Offering,
 
260
            Offering.subject_id == Subject.id,
 
261
            Subject.short_name == self.subject,
 
262
            Offering.semester_id == Semester.id,
 
263
            Semester.year == self.year,
 
264
            Semester.semester == self.semester).one()
 
265
        
 
266
        if self.context is None:
 
267
            raise NotFound()
 
268
 
 
269
    @named_operation('edit')
 
270
    def add_worksheet(self, req, identifier, name, assessable, data, format):
 
271
        """Takes worksheet data and adds it."""
 
272
        
 
273
        new_worksheet = Worksheet()
 
274
        new_worksheet.seq_no = self.context.worksheets.count()
 
275
        # Setting new_worksheet.offering implicitly adds new_worksheet,
 
276
        # hence worksheets.count MUST be called above it
 
277
        new_worksheet.offering = self.context
 
278
        new_worksheet.identifier = unicode(identifier)
 
279
        new_worksheet.name = unicode(name)
 
280
        new_worksheet.assessable = self.convert_bool(assessable)
 
281
        new_worksheet.data = unicode(data)
 
282
        new_worksheet.format = unicode(format)
 
283
        
 
284
        # This call is added for clarity, as the worksheet is implicitly added.        
 
285
        req.store.add(new_worksheet)
 
286
        
 
287
        ivle.worksheet.update_exerciselist(new_worksheet)
 
288
        
 
289
        return {"result": "ok"}
 
290
 
 
291
    @named_operation('edit')
 
292
    def move_up(self, req, worksheetid):
 
293
        """Takes a list of worksheet-seq_no pairs and updates their 
 
294
        corresponding Worksheet objects to match."""
 
295
        
 
296
        worksheet_below = req.store.find(Worksheet,
 
297
            Worksheet.offering_id == self.context.id,
 
298
            Worksheet.identifier == unicode(worksheetid)).one()
 
299
        if worksheet_below is None:
 
300
            raise NotFound('worksheet_below')
 
301
        worksheet_above = req.store.find(Worksheet,
 
302
            Worksheet.offering_id == self.context.id,
 
303
            Worksheet.seq_no == (worksheet_below.seq_no - 1)).one()
 
304
        if worksheet_above is None:
 
305
            raise NotFound('worksheet_above')
 
306
 
 
307
        worksheet_below.seq_no = worksheet_below.seq_no - 1
 
308
        worksheet_above.seq_no = worksheet_above.seq_no + 1
 
309
        
 
310
        return {'result': 'ok'}
 
311
 
 
312
    @named_operation('edit')
 
313
    def move_down(self, req, worksheetid):
 
314
        """Takes a list of worksheet-seq_no pairs and updates their 
 
315
        corresponding Worksheet objects to match."""
 
316
        
 
317
        worksheet_above = req.store.find(Worksheet,
 
318
            Worksheet.offering_id == self.context.id,
 
319
            Worksheet.identifier == unicode(worksheetid)).one()
 
320
        if worksheet_above is None:
 
321
            raise NotFound('worksheet_below')
 
322
        worksheet_below = req.store.find(Worksheet,
 
323
            Worksheet.offering_id == self.context.id,
 
324
            Worksheet.seq_no == (worksheet_above.seq_no + 1)).one()
 
325
        if worksheet_below is None:
 
326
            raise NotFound('worksheet_above')
 
327
 
 
328
        worksheet_below.seq_no = worksheet_below.seq_no - 1
 
329
        worksheet_above.seq_no = worksheet_above.seq_no + 1
 
330
        
 
331
        return {'result': 'ok'}