← 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

Expose media on the public site.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/webapp/tutorial/service.py
19
19
 
20
20
'''AJAX backend for the tutorial application.'''
21
21
 
 
22
import os
22
23
import datetime
23
 
 
24
24
import genshi
25
 
from storm.locals import Store
26
25
 
 
26
import ivle.util
 
27
import ivle.console
27
28
import ivle.database
28
29
from ivle.database import Exercise, ExerciseAttempt, ExerciseSave, Worksheet, \
29
 
                          Offering, Subject, Semester, User, WorksheetExercise
30
 
import ivle.worksheet.utils
31
 
from ivle.webapp.base.rest import (JSONRESTView, write_operation,
 
30
                          Offering, Subject, Semester, WorksheetExercise
 
31
import ivle.worksheet
 
32
import ivle.conf
 
33
import ivle.webapp.tutorial.test
 
34
 
 
35
from ivle.webapp.base.rest import (JSONRESTView, named_operation,
32
36
                                   require_permission)
33
37
from ivle.webapp.errors import NotFound
34
38
 
 
39
# If True, getattempts or getattempt will allow browsing of inactive/disabled
 
40
# attempts. If False, will not allow this.
 
41
HISTORY_ALLOW_INACTIVE = False
35
42
 
36
43
TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S'
37
44
 
38
 
 
39
45
class AttemptsRESTView(JSONRESTView):
40
46
    '''REST view of a user's attempts at an exercise.'''
 
47
    
 
48
    def __init__(self, req, subject, year, semester, worksheet, 
 
49
                                                exercise, username):
 
50
        self.user = ivle.database.User.get_by_login(req.store, username)
 
51
        if self.user is None:
 
52
            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.
41
65
 
42
66
    @require_permission('edit')
43
67
    def GET(self, req):
44
68
        """Handles a GET Attempts action."""
45
69
        attempts = req.store.find(ExerciseAttempt, 
46
 
                ExerciseAttempt.ws_ex_id == self.context.worksheet_exercise.id,
47
 
                ExerciseAttempt.user_id == self.context.user.id)
 
70
                ExerciseAttempt.ws_ex_id == self.worksheet_exercise.id,
 
71
                ExerciseAttempt.user_id == self.user.id)
48
72
        # attempts is a list of ExerciseAttempt objects. Convert to dictionaries
49
73
        time_fmt = lambda dt: datetime.datetime.strftime(dt, TIMESTAMP_FORMAT)
50
74
        attempts = [{'date': time_fmt(a.date), 'complete': a.complete}
56
80
    @require_permission('edit')
57
81
    def PUT(self, req, data):
58
82
        """ Tests the given submission """
59
 
        test_results = ivle.worksheet.utils.test_exercise_submission(
60
 
            req.config, req.user, self.context.worksheet_exercise.exercise,
61
 
            data['code'])
 
83
        exercise = req.store.find(Exercise, 
 
84
            Exercise.id == self.worksheet_exercise.exercise_id).one()
 
85
        if exercise is None:
 
86
            raise NotFound()
 
87
 
 
88
        # Start a console to run the tests on
 
89
        jail_path = os.path.join(ivle.conf.jail_base, req.user.login)
 
90
        working_dir = os.path.join("/home", req.user.login)
 
91
        cons = ivle.console.Console(req.user.unixid, jail_path, working_dir)
 
92
 
 
93
        # Parse the file into a exercise object using the test suite
 
94
        exercise_obj = ivle.webapp.tutorial.test.parse_exercise_file(
 
95
                                                            exercise, cons)
 
96
 
 
97
        # Run the test cases. Get the result back as a JSONable object.
 
98
        # Return it.
 
99
        test_results = exercise_obj.run_tests(data['code'])
 
100
 
 
101
        # Close the console
 
102
        cons.close()
62
103
 
63
104
        attempt = ivle.database.ExerciseAttempt(user=req.user,
64
 
            worksheet_exercise = self.context.worksheet_exercise,
 
105
            worksheet_exercise = self.worksheet_exercise,
65
106
            date = datetime.datetime.now(),
66
107
            complete = test_results['passed'],
67
108
            text = unicode(data['code'])
72
113
        # Query the DB to get an updated score on whether or not this problem
73
114
        # has EVER been completed (may be different from "passed", if it has
74
115
        # been completed before), and the total number of attempts.
75
 
        completed, attempts = ivle.worksheet.utils.get_exercise_status(
76
 
                req.store, req.user, self.context.worksheet_exercise)
 
116
        completed, attempts = ivle.worksheet.get_exercise_status(req.store,
 
117
            req.user, self.worksheet_exercise)
77
118
        test_results["completed"] = completed
78
119
        test_results["attempts"] = attempts
79
120
 
83
124
class AttemptRESTView(JSONRESTView):
84
125
    '''REST view of an exercise attempt.'''
85
126
 
 
127
    def __init__(self, req, subject, year, semester, worksheet, exercise, 
 
128
                 username, date):
 
129
        # TODO: Find exercise within worksheet.
 
130
        user = ivle.database.User.get_by_login(req.store, username)
 
131
        if user is None:
 
132
            raise NotFound()
 
133
 
 
134
        try:
 
135
            date = datetime.datetime.strptime(date, TIMESTAMP_FORMAT)
 
136
        except ValueError:
 
137
            raise NotFound()
 
138
 
 
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
            
 
150
        attempt = ivle.worksheet.get_exercise_attempt(req.store, user,
 
151
                        worksheet_exercise, as_of=date,
 
152
                        allow_inactive=HISTORY_ALLOW_INACTIVE) 
 
153
 
 
154
        if attempt is None:
 
155
            raise NotFound()
 
156
 
 
157
        self.context = attempt
 
158
 
86
159
    @require_permission('view')
87
160
    def GET(self, req):
88
161
        return {'code': self.context.text}
89
162
 
90
163
 
91
 
class WorksheetExerciseRESTView(JSONRESTView):
92
 
    '''REST view of a worksheet exercise.'''
93
 
 
94
 
    @write_operation('view')
 
164
class ExerciseRESTView(JSONRESTView):
 
165
    '''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')
95
177
    def save(self, req, text):
96
178
        # Find the appropriate WorksheetExercise to save to. If its not found,
97
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()
98
192
 
99
193
        old_save = req.store.find(ExerciseSave,
100
 
            ExerciseSave.ws_ex_id == self.context.id,
 
194
            ExerciseSave.ws_ex_id == worksheet_exercise.id,
101
195
            ExerciseSave.user == req.user).one()
102
196
        
103
197
        #Overwrite the old, or create a new if there isn't one
107
201
        else:
108
202
            new_save = old_save
109
203
        
110
 
        new_save.worksheet_exercise = self.context
 
204
        new_save.worksheet_exercise = worksheet_exercise
111
205
        new_save.user = req.user
112
206
        new_save.text = unicode(text)
113
207
        new_save.date = datetime.datetime.now()
115
209
        return {"result": "ok"}
116
210
 
117
211
 
 
212
def generate_exerciselist(worksheet, req, worksheetdata):
 
213
    """Runs through the worksheetstream, generating the appropriate
 
214
    WorksheetExercises, and de-activating the old ones."""
 
215
    exercises = []
 
216
    # Turns the worksheet into an xml stream, and then finds all the 
 
217
    # exercise nodes in the stream.
 
218
    worksheetdata = genshi.XML(worksheetdata)
 
219
    for kind, data, pos in worksheetdata:
 
220
        if kind is genshi.core.START:
 
221
            # Data is a tuple of tag name and a list of name->value tuples
 
222
            if data[0] == 'exercise':
 
223
                src = ""
 
224
                optional = False
 
225
                for attr in data[1]:
 
226
                    if attr[0] == 'src':
 
227
                        src = attr[1]
 
228
                    if attr[0] == 'optional':
 
229
                        optional = attr[1] == 'true'
 
230
                if src != "":
 
231
                    exercises.append((src, optional))
 
232
    ex_num = 0
 
233
    # Set all current worksheet_exercises to be inactive
 
234
    db_worksheet_exercises = req.store.find(WorksheetExercise,
 
235
        WorksheetExercise.worksheet_id == worksheet.id)
 
236
    for worksheet_exercise in db_worksheet_exercises:
 
237
        worksheet_exercise.active = False
 
238
    
 
239
    for exerciseid, optional in exercises:
 
240
        worksheet_exercise = req.store.find(WorksheetExercise,
 
241
            WorksheetExercise.worksheet_id == worksheet.id,
 
242
            Exercise.id == WorksheetExercise.exercise_id,
 
243
            Exercise.id == exerciseid).one()
 
244
        if worksheet_exercise is None:
 
245
            exercise = req.store.find(Exercise,
 
246
                Exercise.id == exerciseid
 
247
            ).one()
 
248
            if exercise is None:
 
249
                raise NotFound()
 
250
            worksheet_exercise = WorksheetExercise()
 
251
            worksheet_exercise.worksheet_id = worksheet.id
 
252
            worksheet_exercise.exercise_id = exercise.id
 
253
            req.store.add(worksheet_exercise)
 
254
        worksheet_exercise.active = True
 
255
        worksheet_exercise.seq_no = ex_num
 
256
        worksheet_exercise.optional = optional
 
257
 
 
258
 
 
259
# Note that this is the view of an existing worksheet. Creation is handled
 
260
# by OfferingRESTView (as offerings have worksheets)
 
261
class WorksheetRESTView(JSONRESTView):
 
262
    """View used to update a worksheet."""
 
263
 
 
264
    def get_permissions(self, user):
 
265
        # XXX: Do it properly.
 
266
        # XXX: Lecturers should be allowed to add worksheets Only to subjects
 
267
        #      under their control
 
268
        if user is not None:
 
269
            if user.rolenm == 'admin':
 
270
                return set(['save'])
 
271
            else:
 
272
                return set()
 
273
        else:
 
274
            return set()    
 
275
 
 
276
    def __init__(self, req, **kwargs):
 
277
    
 
278
        self.worksheet = kwargs['worksheet']
 
279
        self.subject = kwargs['subject']
 
280
        self.year = kwargs['year']
 
281
        self.semester = kwargs['semester']
 
282
    
 
283
        self.context = req.store.find(Worksheet,
 
284
            Worksheet.identifier == self.worksheet,
 
285
            Worksheet.offering_id == Offering.id,
 
286
            Offering.subject_id == Subject.id,
 
287
            Subject.code == self.subject,
 
288
            Offering.semester_id == Semester.id,
 
289
            Semester.year == self.year,
 
290
            Semester.semester == self.semester).one()
 
291
        
 
292
        if self.context is None:
 
293
            raise NotFound()
 
294
    
 
295
    @named_operation('save')
 
296
    def save(self, req, name, assessable, data, format):
 
297
        """Takes worksheet data and saves it."""
 
298
        generate_exerciselist(self.context, req, data)
 
299
        
 
300
        self.context.name = unicode(name)
 
301
        self.context.assessable = self.convert_bool(assessable)
 
302
        self.context.data = unicode(data)
 
303
        self.context.format = unicode(format)
 
304
        
 
305
        return {"result": "ok"}
 
306
 
118
307
class WorksheetsRESTView(JSONRESTView):
119
308
    """View used to update and create Worksheets."""
120
 
 
121
 
    @write_operation('edit_worksheets')
 
309
    
 
310
    def get_permissions(self, user):
 
311
        # XXX: Do it properly.
 
312
        # XXX: Lecturers should be allowed to add worksheets Only to subjects
 
313
        #      under their control
 
314
        if user is not None:
 
315
            if user.rolenm == 'admin':
 
316
                return set(['edit'])
 
317
            else:
 
318
                return set()
 
319
        else:
 
320
            return set()
 
321
 
 
322
    def __init__(self, req, **kwargs):
 
323
    
 
324
        self.subject = kwargs['subject']
 
325
        self.year = kwargs['year']
 
326
        self.semester = kwargs['semester']
 
327
    
 
328
        self.context = req.store.find(Offering,
 
329
            Offering.subject_id == Subject.id,
 
330
            Subject.code == self.subject,
 
331
            Offering.semester_id == Semester.id,
 
332
            Semester.year == self.year,
 
333
            Semester.semester == self.semester).one()
 
334
        
 
335
        if self.context is None:
 
336
            raise NotFound()
 
337
 
 
338
    @named_operation('edit')
 
339
    def add_worksheet(self, req, identifier, name, assessable, data, format):
 
340
        """Takes worksheet data and adds it."""
 
341
        
 
342
        new_worksheet = Worksheet()
 
343
        new_worksheet.seq_no = self.context.worksheets.count()
 
344
        # Setting new_worksheet.offering implicitly adds new_worksheet,
 
345
        # hence worksheets.count MUST be called above it
 
346
        new_worksheet.offering = self.context
 
347
        new_worksheet.identifier = unicode(identifier)
 
348
        new_worksheet.name = unicode(name)
 
349
        new_worksheet.assessable = self.convert_bool(assessable)
 
350
        new_worksheet.data = unicode(data)
 
351
        new_worksheet.format = unicode(format)
 
352
        
 
353
        # This call is added for clarity, as the worksheet is implicitly added.        
 
354
        req.store.add(new_worksheet)
 
355
        
 
356
        generate_exerciselist(new_worksheet, req, data)
 
357
        
 
358
        return {"result": "ok"}
 
359
 
 
360
    @named_operation('edit')
122
361
    def move_up(self, req, worksheetid):
123
362
        """Takes a list of worksheet-seq_no pairs and updates their 
124
363
        corresponding Worksheet objects to match."""
139
378
        
140
379
        return {'result': 'ok'}
141
380
 
142
 
    @write_operation('edit_worksheets')
 
381
    @named_operation('edit')
143
382
    def move_down(self, req, worksheetid):
144
383
        """Takes a list of worksheet-seq_no pairs and updates their 
145
384
        corresponding Worksheet objects to match."""