← 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

Fix a reference typo in ivle.database.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/webapp/tutorial/service.py
 
1
# IVLE - Informatics Virtual Learning Environment
 
2
# Copyright (C) 2007-2009 The University of Melbourne
 
3
#
 
4
# This program is free software; you can redistribute it and/or modify
 
5
# it under the terms of the GNU General Public License as published by
 
6
# the Free Software Foundation; either version 2 of the License, or
 
7
# (at your option) any later version.
 
8
#
 
9
# This program is distributed in the hope that it will be useful,
 
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
# GNU General Public License for more details.
 
13
#
 
14
# You should have received a copy of the GNU General Public License
 
15
# along with this program; if not, write to the Free Software
 
16
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
17
 
 
18
# Author: Matt Giuca, Nick Chadwick
 
19
 
 
20
'''AJAX backend for the tutorial application.'''
 
21
 
 
22
import os
 
23
import datetime
 
24
import genshi
 
25
 
 
26
import ivle.util
 
27
import ivle.console
 
28
import ivle.database
 
29
from ivle.database import Exercise, ExerciseAttempt, ExerciseSave, Worksheet, \
 
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,
 
36
                                   require_permission)
 
37
from ivle.webapp.errors import NotFound
 
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
 
42
 
 
43
TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S'
 
44
 
 
45
class AttemptsRESTView(JSONRESTView):
 
46
    '''REST view of a user's attempts at an exercise.'''
 
47
    def __init__(self, req, subject, year, semester, worksheet, 
 
48
                                                exercise, username):
 
49
        self.user = ivle.database.User.get_by_login(req.store, username)
 
50
        if self.user is None:
 
51
            raise NotFound()
 
52
        
 
53
        self.worksheet_exercise = req.store.find(WorksheetExercise,
 
54
            WorksheetExercise.exercise_id == exercise,
 
55
            WorksheetExercise.worksheet_id == Worksheet.id,
 
56
            Worksheet.offering_id == Offering.id,
 
57
            Offering.subject_id == Subject.id,
 
58
            Subject.code == subject,
 
59
            Offering.semester_id == Semester.id,
 
60
            Semester.year == year,
 
61
            Semester.semester == semester).one()
 
62
        
 
63
        self.context = self.user # XXX: Not quite right.
 
64
 
 
65
    @require_permission('edit')
 
66
    def GET(self, req):
 
67
        """Handles a GET Attempts action."""
 
68
        attempts = req.store.find(ExerciseAttempt, 
 
69
                ExerciseAttempt.ws_ex_id == self.worksheet_exercise.id,
 
70
                ExerciseAttempt.user_id == self.user.id)
 
71
        # attempts is a list of ExerciseAttempt objects. Convert to dictionaries
 
72
        time_fmt = lambda dt: datetime.datetime.strftime(dt, TIMESTAMP_FORMAT)
 
73
        attempts = [{'date': time_fmt(a.date), 'complete': a.complete}
 
74
                for a in attempts]
 
75
 
 
76
        return attempts
 
77
 
 
78
 
 
79
    @require_permission('edit')
 
80
    def PUT(self, req, data):
 
81
        """ Tests the given submission """
 
82
        exercise = req.store.find(Exercise, 
 
83
            Exercise.id == self.worksheet_exercise.exercise_id).one()
 
84
        if exercise is None:
 
85
            raise NotFound()
 
86
 
 
87
        # Start a console to run the tests on
 
88
        jail_path = os.path.join(ivle.conf.jail_base, req.user.login)
 
89
        working_dir = os.path.join("/home", req.user.login)
 
90
        cons = ivle.console.Console(req.user.unixid, jail_path, working_dir)
 
91
 
 
92
        # Parse the file into a exercise object using the test suite
 
93
        exercise_obj = ivle.webapp.tutorial.test.parse_exercise_file(
 
94
                                                            exercise, cons)
 
95
 
 
96
        # Run the test cases. Get the result back as a JSONable object.
 
97
        # Return it.
 
98
        test_results = exercise_obj.run_tests(data['code'])
 
99
 
 
100
        # Close the console
 
101
        cons.close()
 
102
 
 
103
        attempt = ivle.database.ExerciseAttempt(user=req.user,
 
104
            worksheet_exercise = self.worksheet_exercise,
 
105
            date = datetime.datetime.now(),
 
106
            complete = test_results['passed'],
 
107
            text = unicode(data['code'])
 
108
        )
 
109
 
 
110
        req.store.add(attempt)
 
111
 
 
112
        # Query the DB to get an updated score on whether or not this problem
 
113
        # has EVER been completed (may be different from "passed", if it has
 
114
        # been completed before), and the total number of attempts.
 
115
        completed, attempts = ivle.worksheet.get_exercise_status(req.store,
 
116
            req.user, self.worksheet_exercise)
 
117
        test_results["completed"] = completed
 
118
        test_results["attempts"] = attempts
 
119
 
 
120
        return test_results
 
121
 
 
122
 
 
123
class AttemptRESTView(JSONRESTView):
 
124
    '''REST view of an exercise attempt.'''
 
125
 
 
126
    def __init__(self, req, subject, year, semester, worksheet, exercise, 
 
127
                 username, date):
 
128
        # TODO: Find exercise within worksheet.
 
129
        user = ivle.database.User.get_by_login(req.store, username)
 
130
        if user is None:
 
131
            raise NotFound()
 
132
 
 
133
        #try:
 
134
        #    date = datetime.datetime.strptime(date, TIMESTAMP_FORMAT)
 
135
        #except ValueError:
 
136
        #    raise NotFound()
 
137
 
 
138
        worksheet_exercise = req.store.find(WorksheetExercise,
 
139
            WorksheetExercise.exercise_id == exercise,
 
140
            WorksheetExercise.worksheet_id == Worksheet.id,
 
141
            Worksheet.identifier == worksheet,
 
142
            Worksheet.offering_id == Offering.id,
 
143
            Offering.subject_id == Subject.id,
 
144
            Subject.code == subject,
 
145
            Offering.semester_id == Semester.id,
 
146
            Semester.year == year,
 
147
            Semester.semester == semester).one()
 
148
            
 
149
        attempt = req.store.find(ExerciseAttempt,
 
150
            ExerciseAttempt.user_id == user.id,
 
151
            ExerciseAttempt.ws_ex_id == worksheet_exercise.id,
 
152
            ExerciseAttempt.date == date
 
153
        ).one()
 
154
 
 
155
        if attempt is None:
 
156
            raise NotFound()
 
157
 
 
158
        self.context = attempt
 
159
 
 
160
    @require_permission('view')
 
161
    def GET(self, req):
 
162
        return {'code': self.context.text}
 
163
 
 
164
 
 
165
class ExerciseRESTView(JSONRESTView):
 
166
    '''REST view of an exercise.'''
 
167
 
 
168
    def get_permissions(self, user):
 
169
        # XXX: Do it properly.
 
170
        # XXX: Does any user have the ability to save as themselves?
 
171
        # XXX: Does a user EVER have permission to save as another user?
 
172
        if user is not None:
 
173
            return set(['save'])
 
174
        else:
 
175
            return set()
 
176
 
 
177
    @named_operation('save')
 
178
    def save(self, req, text):
 
179
        # Find the appropriate WorksheetExercise to save to. If its not found,
 
180
        # the user is submitting against a non-existant worksheet/exercise
 
181
        worksheet_exercise = req.store.find(WorksheetExercise,
 
182
            WorksheetExercise.exercise_id == self.exercise,
 
183
            WorksheetExercise.worksheet_id == Worksheet.id,
 
184
            Worksheet.offering_id == Offering.id,
 
185
            Offering.subject_id == Subject.id,
 
186
            Subject.code == self.subject,
 
187
            Offering.semester_id == Semester.id,
 
188
            Semester.year == self.year,
 
189
            Semester.semester == self.semester).one()
 
190
        
 
191
        if worksheet_exercise is None:
 
192
            raise NotFound()
 
193
 
 
194
        old_save = req.store.find(ExerciseSave,
 
195
            ExerciseSave.ws_ex_id == worksheet_exercise.id,
 
196
            ExerciseSave.user == req.user).one()
 
197
        
 
198
        #Overwrite the old, or create a new if there isn't one
 
199
        if old_save is None:
 
200
            new_save = ExerciseSave()
 
201
            req.store.add(new_save)
 
202
        else:
 
203
            new_save = old_save
 
204
        
 
205
        new_save.worksheet_exercise = worksheet_exercise
 
206
        new_save.user = req.user
 
207
        new_save.text = unicode(text)
 
208
        new_save.date = datetime.datetime.now()
 
209
 
 
210
        return {"result": "ok"}
 
211
 
 
212
 
 
213
def generate_exerciselist(worksheet, req, worksheetdata):
 
214
    """Runs through the worksheetstream, generating the appropriate
 
215
    WorksheetExercises, and de-activating the old ones."""
 
216
    exercises = []
 
217
    # Turns the worksheet into an xml stream, and then finds all the 
 
218
    # exercise nodes in the stream.
 
219
    worksheetdata = genshi.XML(worksheetdata)
 
220
    for kind, data, pos in worksheetdata:
 
221
        if kind is genshi.core.START:
 
222
            # Data is a tuple of tag name and a list of name->value tuples
 
223
            if data[0] == 'exercise':
 
224
                src = ""
 
225
                optional = False
 
226
                for attr in data[1]:
 
227
                    if attr[0] == 'src':
 
228
                        src = attr[1]
 
229
                    if attr[0] == 'optional':
 
230
                        optional = attr[1] == 'true'
 
231
                if src != "":
 
232
                    exercises.append((src, optional))
 
233
    ex_num = 0
 
234
    # Set all current worksheet_exercises to be inactive
 
235
    db_worksheet_exercises = req.store.find(WorksheetExercise,
 
236
        WorksheetExercise.worksheet_id == worksheet.id)
 
237
    for worksheet_exercise in db_worksheet_exercises:
 
238
        worksheet_exercise.active = False
 
239
    
 
240
    for exerciseid, optional in exercises:
 
241
        worksheet_exercise = req.store.find(WorksheetExercise,
 
242
            WorksheetExercise.worksheet_id == worksheet.id,
 
243
            Exercise.id == WorksheetExercise.exercise_id,
 
244
            Exercise.id == exerciseid).one()
 
245
        if worksheet_exercise is None:
 
246
            exercise = req.store.find(Exercise,
 
247
                Exercise.id == exerciseid
 
248
            ).one()
 
249
            if exercise is None:
 
250
                raise NotFound()
 
251
            worksheet_exercise = WorksheetExercise()
 
252
            worksheet_exercise.worksheet_id = worksheet.id
 
253
            worksheet_exercise.exercise_id = exercise.id
 
254
            req.store.add(worksheet_exercise)
 
255
        worksheet_exercise.active = True
 
256
        worksheet_exercise.seq_no = ex_num
 
257
        worksheet_exercise.optional = optional
 
258
 
 
259
 
 
260
# Note that this is the view of an existing worksheet. Creation is handled
 
261
# by OfferingRESTView (as offerings have worksheets)
 
262
class WorksheetRESTView(JSONRESTView):
 
263
    """View used to update a worksheet."""
 
264
 
 
265
    def get_permissions(self, user):
 
266
        # XXX: Do it properly.
 
267
        # XXX: Lecturers should be allowed to add worksheets Only to subjects
 
268
        #      under their control
 
269
        if user is not None:
 
270
            if user.rolenm == 'admin':
 
271
                return set(['save'])
 
272
            else:
 
273
                return set()
 
274
        else:
 
275
            return set()    
 
276
 
 
277
    def __init__(self, req, **kwargs):
 
278
    
 
279
        self.worksheet = kwargs['worksheet']
 
280
        self.subject = kwargs['subject']
 
281
        self.year = kwargs['year']
 
282
        self.semester = kwargs['semester']
 
283
    
 
284
        self.context = req.store.find(Worksheet,
 
285
            Worksheet.identifier == self.worksheet,
 
286
            Worksheet.offering_id == Offering.id,
 
287
            Offering.subject_id == Subject.id,
 
288
            Subject.code == self.subject,
 
289
            Offering.semester_id == Semester.id,
 
290
            Semester.year == self.year,
 
291
            Semester.semester == self.semester).one()
 
292
        
 
293
        if self.context is None:
 
294
            raise NotFound()
 
295
    
 
296
    @named_operation('save')
 
297
    def save(self, req, name, assessable, data, format):
 
298
        """Takes worksheet data and saves it."""
 
299
        self.generate_exerciselist(self.context, req, data)
 
300
        
 
301
        self.context.name = unicode(name)
 
302
        self.context.assessable = self.convert_bool(assessable)
 
303
        self.context.data = unicode(data)
 
304
        
 
305
        return {"result": "ok"}
 
306
 
 
307
class OfferingRESTView(JSONRESTView):
 
308
    """View used to update Offering and create 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(['add_worksheet'])
 
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('add_worksheet')
 
339
    def add_worksheet(self,req, identifier, name, assessable, data, format):
 
340
        """Takes worksheet data and adds it."""
 
341
        
 
342
        new_worksheet = Worksheet()
 
343
        
 
344
        new_worksheet.offering = self.context
 
345
        new_worksheet.identifier = unicode(identifier)
 
346
        new_worksheet.name = unicode(name)
 
347
        new_worksheet.assessable = self.convert_bool(assessable)
 
348
        new_worksheet.data = unicode(data)
 
349
        new_worksheet.format = unicode(format)
 
350
        new_worksheet.seq_no = self.context.worksheets.count()
 
351
        req.store.add(new_worksheet)
 
352
        
 
353
        generate_exerciselist(new_worksheet, req, data)
 
354
        
 
355
        return {"result": "ok"}
 
356