← 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-05-28 02:43:56 UTC
  • Revision ID: grantw@unimelb.edu.au-20090528024356-mlrhizz7omnr71hd
Test ivle.mimetypes.nice_filetype.

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
 
import ivle.util
26
26
import ivle.console
27
27
import ivle.database
28
 
from ivle.database import Exercise, ExerciseAttempt, ExerciseSave, Worksheet, Offering, Subject, Semester
29
 
import ivle.worksheet
30
 
import ivle.conf
 
28
from ivle.database import Exercise, ExerciseAttempt, ExerciseSave, Worksheet, \
 
29
                          Offering, Subject, Semester, WorksheetExercise
 
30
import ivle.worksheet.utils
31
31
import ivle.webapp.tutorial.test
32
 
 
33
32
from ivle.webapp.base.rest import (JSONRESTView, named_operation,
34
33
                                   require_permission)
35
34
from ivle.webapp.errors import NotFound
40
39
 
41
40
TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S'
42
41
 
43
 
 
44
42
class AttemptsRESTView(JSONRESTView):
45
43
    '''REST view of a user's attempts at an exercise.'''
 
44
    
46
45
    def __init__(self, req, subject, year, semester, worksheet, 
47
46
                                                exercise, username):
48
47
        self.user = ivle.database.User.get_by_login(req.store, username)
49
48
        if self.user is None:
50
49
            raise NotFound()
51
 
        self.exercise = exercise
52
50
        
53
 
        self.worksheet = req.store.find(Worksheet,
54
 
            Worksheet.name == worksheet,
 
51
        self.worksheet_exercise = req.store.find(WorksheetExercise,
 
52
            WorksheetExercise.exercise_id == unicode(exercise),
 
53
            WorksheetExercise.worksheet_id == Worksheet.id,
55
54
            Worksheet.offering_id == Offering.id,
 
55
            Worksheet.identifier == unicode(worksheet),
56
56
            Offering.subject_id == Subject.id,
57
 
            Subject.code == subject,
 
57
            Subject.short_name == subject,
58
58
            Offering.semester_id == Semester.id,
59
59
            Semester.year == year,
60
60
            Semester.semester == semester).one()
64
64
    @require_permission('edit')
65
65
    def GET(self, req):
66
66
        """Handles a GET Attempts action."""
67
 
        exercise = req.store.find(Exercise, Exercise.id == self.exercise).one()
68
 
 
69
67
        attempts = req.store.find(ExerciseAttempt, 
70
 
                ExerciseAttempt.exercise_id == exercise.id,
 
68
                ExerciseAttempt.ws_ex_id == self.worksheet_exercise.id,
71
69
                ExerciseAttempt.user_id == self.user.id)
72
70
        # attempts is a list of ExerciseAttempt objects. Convert to dictionaries
73
71
        time_fmt = lambda dt: datetime.datetime.strftime(dt, TIMESTAMP_FORMAT)
80
78
    @require_permission('edit')
81
79
    def PUT(self, req, data):
82
80
        """ Tests the given submission """
83
 
        exercise = req.store.find(Exercise, Exercise.id == self.exercise).one()
 
81
        exercise = req.store.find(Exercise, 
 
82
            Exercise.id == self.worksheet_exercise.exercise_id).one()
84
83
        if exercise is None:
85
84
            raise NotFound()
86
85
 
87
86
        # Start a console to run the tests on
88
 
        jail_path = os.path.join(ivle.conf.jail_base, req.user.login)
 
87
        jail_path = os.path.join(req.config['paths']['jails']['mounts'],
 
88
                                 req.user.login)
89
89
        working_dir = os.path.join("/home", req.user.login)
90
 
        cons = ivle.console.Console(req.user.unixid, jail_path, working_dir)
 
90
        cons = ivle.console.Console(req.config, req.user.unixid, jail_path,
 
91
                                    working_dir)
91
92
 
92
93
        # Parse the file into a exercise object using the test suite
93
94
        exercise_obj = ivle.webapp.tutorial.test.parse_exercise_file(
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
 
112
113
        # Query the DB to get an updated score on whether or not this problem
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
 
        completed, attempts = ivle.worksheet.get_exercise_status(req.store,
116
 
            req.user, exercise, self.worksheet)
 
116
        completed, attempts = ivle.worksheet.utils.get_exercise_status(
 
117
                req.store, 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
 
 
147
 
        attempt = ivle.worksheet.get_exercise_attempt(req.store, user,
148
 
            exercise, worksheet, as_of=date, allow_inactive=HISTORY_ALLOW_INACTIVE)
 
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) 
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
# 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,
178
228
            Worksheet.offering_id == Offering.id,
179
229
            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"}
 
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'}