← 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-07-31 04:26:02 UTC
  • mfrom: (1281.1.9 aufsless)
  • Revision ID: me@williamgrant.id.au-20090731042602-51tp90sv3icl7iqv
Jails no longer use aufs, but bind mounts. Both parts of the jails must be rebuilt.

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
 
 
25
24
import genshi
26
 
from storm.locals import Store
27
25
 
28
26
import ivle.console
29
27
import ivle.database
30
28
from ivle.database import Exercise, ExerciseAttempt, ExerciseSave, Worksheet, \
31
 
                          Offering, Subject, Semester, User, WorksheetExercise
 
29
                          Offering, Subject, Semester, WorksheetExercise
32
30
import ivle.worksheet.utils
33
31
import ivle.webapp.tutorial.test
34
32
from ivle.webapp.base.rest import (JSONRESTView, named_operation,
35
33
                                   require_permission)
36
34
from ivle.webapp.errors import NotFound
37
35
 
 
36
# If True, getattempts or getattempt will allow browsing of inactive/disabled
 
37
# attempts. If False, will not allow this.
 
38
HISTORY_ALLOW_INACTIVE = False
38
39
 
39
40
TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S'
40
41
 
41
42
class AttemptsRESTView(JSONRESTView):
42
43
    '''REST view of a user's attempts at an exercise.'''
 
44
    
 
45
    def __init__(self, req, subject, year, semester, worksheet, 
 
46
                                                exercise, username):
 
47
        self.user = ivle.database.User.get_by_login(req.store, username)
 
48
        if self.user is None:
 
49
            raise NotFound()
 
50
        
 
51
        self.worksheet_exercise = req.store.find(WorksheetExercise,
 
52
            WorksheetExercise.exercise_id == unicode(exercise),
 
53
            WorksheetExercise.worksheet_id == Worksheet.id,
 
54
            Worksheet.offering_id == Offering.id,
 
55
            Worksheet.identifier == unicode(worksheet),
 
56
            Offering.subject_id == Subject.id,
 
57
            Subject.short_name == subject,
 
58
            Offering.semester_id == Semester.id,
 
59
            Semester.year == year,
 
60
            Semester.semester == semester).one()
 
61
        
 
62
        self.context = self.user # XXX: Not quite right.
43
63
 
44
64
    @require_permission('edit')
45
65
    def GET(self, req):
46
66
        """Handles a GET Attempts action."""
47
67
        attempts = req.store.find(ExerciseAttempt, 
48
 
                ExerciseAttempt.ws_ex_id == self.context.worksheet_exercise.id,
49
 
                ExerciseAttempt.user_id == self.context.user.id)
 
68
                ExerciseAttempt.ws_ex_id == self.worksheet_exercise.id,
 
69
                ExerciseAttempt.user_id == self.user.id)
50
70
        # attempts is a list of ExerciseAttempt objects. Convert to dictionaries
51
71
        time_fmt = lambda dt: datetime.datetime.strftime(dt, TIMESTAMP_FORMAT)
52
72
        attempts = [{'date': time_fmt(a.date), 'complete': a.complete}
58
78
    @require_permission('edit')
59
79
    def PUT(self, req, data):
60
80
        """ Tests the given submission """
 
81
        exercise = req.store.find(Exercise, 
 
82
            Exercise.id == self.worksheet_exercise.exercise_id).one()
 
83
        if exercise is None:
 
84
            raise NotFound()
 
85
 
61
86
        # Start a console to run the tests on
62
87
        jail_path = os.path.join(req.config['paths']['jails']['mounts'],
63
88
                                 req.user.login)
67
92
 
68
93
        # Parse the file into a exercise object using the test suite
69
94
        exercise_obj = ivle.webapp.tutorial.test.parse_exercise_file(
70
 
                            self.context.worksheet_exercise.exercise, cons)
 
95
                                                            exercise, cons)
71
96
 
72
97
        # Run the test cases. Get the result back as a JSONable object.
73
98
        # Return it.
77
102
        cons.close()
78
103
 
79
104
        attempt = ivle.database.ExerciseAttempt(user=req.user,
80
 
            worksheet_exercise = self.context.worksheet_exercise,
 
105
            worksheet_exercise = self.worksheet_exercise,
81
106
            date = datetime.datetime.now(),
82
107
            complete = test_results['passed'],
83
108
            text = unicode(data['code'])
89
114
        # has EVER been completed (may be different from "passed", if it has
90
115
        # been completed before), and the total number of attempts.
91
116
        completed, attempts = ivle.worksheet.utils.get_exercise_status(
92
 
                req.store, req.user, self.context.worksheet_exercise)
 
117
                req.store, req.user, self.worksheet_exercise)
93
118
        test_results["completed"] = completed
94
119
        test_results["attempts"] = attempts
95
120
 
99
124
class AttemptRESTView(JSONRESTView):
100
125
    '''REST view of an exercise attempt.'''
101
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
        # 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,
 
152
            Worksheet.offering_id == Offering.id,
 
153
            Offering.subject_id == Subject.id,
 
154
            Subject.short_name == subject,
 
155
            Offering.semester_id == Semester.id,
 
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) 
 
162
 
 
163
        if attempt is None:
 
164
            raise NotFound()
 
165
 
 
166
        self.context = attempt
 
167
 
102
168
    @require_permission('view')
103
169
    def GET(self, req):
104
170
        return {'code': self.context.text}
107
173
class WorksheetExerciseRESTView(JSONRESTView):
108
174
    '''REST view of a worksheet exercise.'''
109
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
 
110
190
    @named_operation('view')
111
191
    def save(self, req, text):
112
192
        # Find the appropriate WorksheetExercise to save to. If its not found,
136
216
class WorksheetRESTView(JSONRESTView):
137
217
    """View used to update a worksheet."""
138
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,
 
228
            Worksheet.offering_id == Offering.id,
 
229
            Offering.subject_id == Subject.id,
 
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
    
139
238
    @named_operation('edit')
140
239
    def save(self, req, name, assessable, data, format):
141
240
        """Takes worksheet data and saves it."""
149
248
 
150
249
class WorksheetsRESTView(JSONRESTView):
151
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()
152
267
 
153
268
    @named_operation('edit')
154
269
    def add_worksheet(self, req, identifier, name, assessable, data, format):