← 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-05 03:18:14 UTC
  • mto: (1294.4.2 ui-the-third)
  • mto: This revision was merged to the branch mainline in revision 1353.
  • Revision ID: grantw@unimelb.edu.au-20090705031814-yn8oymmawsq0da78
Split out ivle.webapp.admin's routes into annotated functions in ivle.webapp.traversal.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/webapp/tutorial/service.py
1
1
# IVLE - Informatics Virtual Learning Environment
2
 
# Copyright (C) 2007-2008 The University of Melbourne
 
2
# Copyright (C) 2007-2009 The University of Melbourne
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
5
5
# it under the terms of the GNU General Public License as published by
15
15
# along with this program; if not, write to the Free Software
16
16
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17
17
 
18
 
# Module: TutorialService
19
 
# Author: Matt Giuca
20
 
# Date:   25/1/2008
21
 
 
22
 
# Provides the AJAX backend for the tutorial application.
23
 
# This allows several actions to be performed on the code the student has
24
 
# typed into one of the exercise boxes.
25
 
 
26
 
# Calling syntax
27
 
# Path must be empty.
28
 
# The arguments determine what is to be done on this file.
29
 
 
30
 
# "action". One of the tutorialservice actions.
31
 
# "exercise" - The path to a exercise file (including the .xml extension),
32
 
#              relative to the subjects base directory.
33
 
# action "save" or "test" (POST only):
34
 
#   "code" - Full text of the student's code being submitted.
35
 
# action "getattempts": No arguments. Returns a list of
36
 
#   {'date': 'formatted_date', 'complete': bool} dicts.
37
 
# action "getattempt":
38
 
#   "date" - Formatted date. Gets most recent attempt before (and including)
39
 
#   that date.
40
 
#   Returns JSON string containing code, or null.
41
 
 
42
 
# Returns a JSON response string indicating the results.
 
18
# Author: Matt Giuca, Nick Chadwick
 
19
 
 
20
'''AJAX backend for the tutorial application.'''
43
21
 
44
22
import os
45
 
import time
46
 
 
47
 
import cjson
48
 
 
49
 
from common import (db, util)
50
 
import test
51
 
import conf
 
23
import datetime
 
24
 
 
25
import genshi
 
26
from storm.locals import Store
 
27
 
 
28
import ivle.console
 
29
import ivle.database
 
30
from ivle.database import Exercise, ExerciseAttempt, ExerciseSave, Worksheet, \
 
31
                          Offering, Subject, Semester, User, WorksheetExercise
 
32
import ivle.worksheet.utils
 
33
import ivle.webapp.tutorial.test
 
34
from ivle.webapp.base.rest import (JSONRESTView, named_operation,
 
35
                                   require_permission)
 
36
from ivle.webapp.errors import NotFound
52
37
 
53
38
# If True, getattempts or getattempt will allow browsing of inactive/disabled
54
39
# attempts. If False, will not allow this.
55
40
HISTORY_ALLOW_INACTIVE = False
56
41
 
57
 
def handle(req):
58
 
    """Handler for Ajax backend TutorialService app."""
59
 
    # Set request attributes
60
 
    req.write_html_head_foot = False     # No HTML
61
 
 
62
 
    if req.path != "":
63
 
        req.throw_error(req.HTTP_BAD_REQUEST)
64
 
    fields = req.get_fieldstorage()
65
 
    act = fields.getfirst('action')
66
 
    exercise = fields.getfirst('exercise')
67
 
    if act is None or exercise is None:
68
 
        req.throw_error(req.HTTP_BAD_REQUEST)
69
 
    act = act.value
70
 
    exercise = exercise.value
71
 
 
72
 
    if act == 'save' or act == 'test':
73
 
        # Must be POST
74
 
        if req.method != 'POST':
75
 
            req.throw_error(req.HTTP_BAD_REQUEST)
76
 
 
77
 
        code = fields.getfirst('code')
78
 
        if code is None:
79
 
            req.throw_error(req.HTTP_BAD_REQUEST)
80
 
        code = code.value
81
 
 
82
 
        if act == 'save':
83
 
            handle_save(req, exercise, code, fields)
84
 
        else:   # act == "test"
85
 
            handle_test(req, exercise, code, fields)
86
 
    elif act == 'getattempts':
87
 
        handle_getattempts(req, exercise)
88
 
    elif act == 'getattempt':
89
 
        date = fields.getfirst('date')
90
 
        if date is None:
91
 
            req.throw_error(req.HTTP_BAD_REQUEST)
92
 
        date = date.value
93
 
        # Convert into a struct_time
94
 
        # The time *should* be in the same format as the DB (since it should
95
 
        # be bounced back to us from the getattempts output). Assume this.
96
 
        try:
97
 
            date = time.strptime(date, db.TIMESTAMP_FORMAT)
98
 
        except ValueError:
99
 
            # Date was not in correct format
100
 
            req.throw_error(req.HTTP_BAD_REQUEST)
101
 
        handle_getattempt(req, exercise, date)
102
 
    else:
103
 
        req.throw_error(req.HTTP_BAD_REQUEST)
104
 
 
105
 
def handle_save(req, exercise, code, fields):
106
 
    """Handles a save action. This saves the user's code without executing it.
 
42
TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S'
 
43
 
 
44
 
 
45
class ExerciseAttempts(object):
 
46
    """The set of exercise attempts for a user and exercise.
 
47
 
 
48
    A combination of a User and WorksheetExercise, this provides access to
 
49
    the User's ExerciseAttempts.
107
50
    """
108
 
    # Need to open JUST so we know this is a real exercise.
109
 
    # (This avoids users submitting code for bogus exercises).
110
 
    exercisefile = util.open_exercise_file(exercise)
111
 
    if exercisefile is None:
112
 
        req.throw_error(req.HTTP_NOT_FOUND,
113
 
            "The exercise was not found.")
114
 
    exercisefile.close()
115
 
 
116
 
    req.write('{"result": "ok"}')
117
 
 
118
 
    conn = db.DB()
119
 
 
120
 
    try:
121
 
        conn.write_problem_save(
122
 
            login = req.user.login,
123
 
            exercisename = exercise,
124
 
            date = time.localtime(),
125
 
            text = code)
126
 
    finally:
127
 
        conn.close()
128
 
 
129
 
def handle_test(req, exercise, code, fields):
130
 
    """Handles a test action."""
131
 
 
132
 
    exercisefile = util.open_exercise_file(exercise)
133
 
    if exercisefile is None:
134
 
        req.throw_error(req.HTTP_NOT_FOUND,
135
 
            "The exercise was not found.")
136
 
 
137
 
    # Parse the file into a exercise object using the test suite
138
 
    exercise_obj = test.parse_exercise_file(exercisefile)
139
 
    exercisefile.close()
140
 
    # Run the test cases. Get the result back as a JSONable object.
141
 
    # Return it.
142
 
    test_results = exercise_obj.run_tests(code)
143
 
 
144
 
    conn = db.DB()
145
 
    try:
146
 
        conn.insert_problem_attempt(
147
 
            login = req.user.login,
148
 
            exercisename = exercise,
149
 
            date = time.localtime(),
 
51
 
 
52
    def __init__(self, worksheet_exercise, user):
 
53
        self.worksheet_exercise = worksheet_exercise
 
54
        self.user = user
 
55
 
 
56
    def get_permissions(self, user):
 
57
        return self.user.get_permissions(user)
 
58
 
 
59
 
 
60
def exerciseattempts_to_attempt(exercise_attempts, date):
 
61
    try:
 
62
        date = datetime.datetime.strptime(date, TIMESTAMP_FORMAT)
 
63
    except ValueError:
 
64
        return None
 
65
 
 
66
    # XXX Hack around Google Code issue #87
 
67
    # Query from the given date +1 secnod.
 
68
    # Date is in seconds (eg. 3:47:12), while the data is in finer time
 
69
    # (eg. 3:47:12.3625). The query "date <= 3:47:12" will fail because
 
70
    # 3:47:12.3625 is greater. Hence we do the query from +1 second,
 
71
    # "date <= 3:47:13", and it finds the correct submission, UNLESS there
 
72
    # are multiple submissions inside the same second.
 
73
    date += datetime.timedelta(seconds=1)
 
74
 
 
75
    return ivle.worksheet.utils.get_exercise_attempt(
 
76
                Store.of(exercise_attempts.user),
 
77
                exercise_attempts.user, exercise_attempts.worksheet_exercise,
 
78
                as_of=date, allow_inactive=HISTORY_ALLOW_INACTIVE)
 
79
 
 
80
 
 
81
def worksheet_exercise_to_user_attempts(worksheet_exercise, login):
 
82
    user = User.get_by_login(Store.of(worksheet_exercise), login)
 
83
    if user is None:
 
84
        return None
 
85
    return ExerciseAttempts(worksheet_exercise, user)
 
86
 
 
87
 
 
88
def worksheet_to_worksheet_exercise(worksheet, exercise_name):
 
89
    return Store.of(worksheet).find(
 
90
        WorksheetExercise,
 
91
        WorksheetExercise.exercise_id == exercise_name,
 
92
        WorksheetExercise.worksheet == worksheet
 
93
        ).one()
 
94
 
 
95
 
 
96
class AttemptsRESTView(JSONRESTView):
 
97
    '''REST view of a user's attempts at an exercise.'''
 
98
 
 
99
    @require_permission('edit')
 
100
    def GET(self, req):
 
101
        """Handles a GET Attempts action."""
 
102
        attempts = req.store.find(ExerciseAttempt, 
 
103
                ExerciseAttempt.ws_ex_id == self.context.worksheet_exercise.id,
 
104
                ExerciseAttempt.user_id == self.context.user.id)
 
105
        # attempts is a list of ExerciseAttempt objects. Convert to dictionaries
 
106
        time_fmt = lambda dt: datetime.datetime.strftime(dt, TIMESTAMP_FORMAT)
 
107
        attempts = [{'date': time_fmt(a.date), 'complete': a.complete}
 
108
                for a in attempts]
 
109
 
 
110
        return attempts
 
111
 
 
112
 
 
113
    @require_permission('edit')
 
114
    def PUT(self, req, data):
 
115
        """ Tests the given submission """
 
116
        # Start a console to run the tests on
 
117
        jail_path = os.path.join(req.config['paths']['jails']['mounts'],
 
118
                                 req.user.login)
 
119
        working_dir = os.path.join("/home", req.user.login)
 
120
        cons = ivle.console.Console(req.config, req.user.unixid, jail_path,
 
121
                                    working_dir)
 
122
 
 
123
        # Parse the file into a exercise object using the test suite
 
124
        exercise_obj = ivle.webapp.tutorial.test.parse_exercise_file(
 
125
                            self.context.worksheet_exercise.exercise, cons)
 
126
 
 
127
        # Run the test cases. Get the result back as a JSONable object.
 
128
        # Return it.
 
129
        test_results = exercise_obj.run_tests(data['code'])
 
130
 
 
131
        # Close the console
 
132
        cons.close()
 
133
 
 
134
        attempt = ivle.database.ExerciseAttempt(user=req.user,
 
135
            worksheet_exercise = self.context.worksheet_exercise,
 
136
            date = datetime.datetime.now(),
150
137
            complete = test_results['passed'],
151
 
            attempt = code)
 
138
            text = unicode(data['code'])
 
139
        )
 
140
 
 
141
        req.store.add(attempt)
152
142
 
153
143
        # Query the DB to get an updated score on whether or not this problem
154
144
        # has EVER been completed (may be different from "passed", if it has
155
145
        # been completed before), and the total number of attempts.
156
 
        completed, attempts = conn.get_problem_status(req.user.login,
157
 
            exercise)
 
146
        completed, attempts = ivle.worksheet.utils.get_exercise_status(
 
147
                req.store, req.user, self.context.worksheet_exercise)
158
148
        test_results["completed"] = completed
159
149
        test_results["attempts"] = attempts
160
150
 
161
 
        req.write(cjson.encode(test_results))
162
 
    finally:
163
 
        conn.close()
164
 
 
165
 
def handle_getattempts(req, exercise):
166
 
    """Handles a getattempts action."""
167
 
    conn = db.DB()
168
 
    try:
169
 
        attempts = conn.get_problem_attempts(
170
 
            login=req.user.login,
171
 
            exercisename=exercise,
172
 
            allow_inactive=HISTORY_ALLOW_INACTIVE)
173
 
        req.write(cjson.encode(attempts))
174
 
    finally:
175
 
        conn.close()
176
 
 
177
 
def handle_getattempt(req, exercise, date):
178
 
    """Handles a getattempts action. Date is a struct_time."""
179
 
    conn = db.DB()
180
 
    try:
181
 
        attempt = conn.get_problem_attempt(
182
 
            login=req.user.login,
183
 
            exercisename=exercise,
184
 
            as_of=date,
185
 
            allow_inactive=HISTORY_ALLOW_INACTIVE)
186
 
        # attempt may be None; will write "null"
187
 
        req.write(cjson.encode(attempt))
188
 
    finally:
189
 
        conn.close()
 
151
        return test_results
 
152
 
 
153
 
 
154
class AttemptRESTView(JSONRESTView):
 
155
    '''REST view of an exercise attempt.'''
 
156
 
 
157
    @require_permission('view')
 
158
    def GET(self, req):
 
159
        return {'code': self.context.text}
 
160
 
 
161
 
 
162
class WorksheetExerciseRESTView(JSONRESTView):
 
163
    '''REST view of a worksheet exercise.'''
 
164
 
 
165
    @named_operation('view')
 
166
    def save(self, req, text):
 
167
        # Find the appropriate WorksheetExercise to save to. If its not found,
 
168
        # the user is submitting against a non-existant worksheet/exercise
 
169
 
 
170
        old_save = req.store.find(ExerciseSave,
 
171
            ExerciseSave.ws_ex_id == self.context.id,
 
172
            ExerciseSave.user == req.user).one()
 
173
        
 
174
        #Overwrite the old, or create a new if there isn't one
 
175
        if old_save is None:
 
176
            new_save = ExerciseSave()
 
177
            req.store.add(new_save)
 
178
        else:
 
179
            new_save = old_save
 
180
        
 
181
        new_save.worksheet_exercise = self.context
 
182
        new_save.user = req.user
 
183
        new_save.text = unicode(text)
 
184
        new_save.date = datetime.datetime.now()
 
185
 
 
186
        return {"result": "ok"}
 
187
 
 
188
 
 
189
# Note that this is the view of an existing worksheet. Creation is handled
 
190
# by OfferingRESTView (as offerings have worksheets)
 
191
class WorksheetRESTView(JSONRESTView):
 
192
    """View used to update a worksheet."""
 
193
 
 
194
    @named_operation('edit')
 
195
    def save(self, req, name, assessable, data, format):
 
196
        """Takes worksheet data and saves it."""
 
197
        self.context.name = unicode(name)
 
198
        self.context.assessable = self.convert_bool(assessable)
 
199
        self.context.data = unicode(data)
 
200
        self.context.format = unicode(format)
 
201
        ivle.worksheet.utils.update_exerciselist(self.context)
 
202
        
 
203
        return {"result": "ok"}
 
204
 
 
205
class WorksheetsRESTView(JSONRESTView):
 
206
    """View used to update and create Worksheets."""
 
207
 
 
208
    @named_operation('edit')
 
209
    def add_worksheet(self, req, identifier, name, assessable, data, format):
 
210
        """Takes worksheet data and adds it."""
 
211
        
 
212
        new_worksheet = Worksheet()
 
213
        new_worksheet.seq_no = self.context.worksheets.count()
 
214
        # Setting new_worksheet.offering implicitly adds new_worksheet,
 
215
        # hence worksheets.count MUST be called above it
 
216
        new_worksheet.offering = self.context
 
217
        new_worksheet.identifier = unicode(identifier)
 
218
        new_worksheet.name = unicode(name)
 
219
        new_worksheet.assessable = self.convert_bool(assessable)
 
220
        new_worksheet.data = unicode(data)
 
221
        new_worksheet.format = unicode(format)
 
222
        
 
223
        # This call is added for clarity, as the worksheet is implicitly added.        
 
224
        req.store.add(new_worksheet)
 
225
 
 
226
        ivle.worksheet.utils.update_exerciselist(new_worksheet)
 
227
 
 
228
        return {"result": "ok"}
 
229
 
 
230
    @named_operation('edit')
 
231
    def move_up(self, req, worksheetid):
 
232
        """Takes a list of worksheet-seq_no pairs and updates their 
 
233
        corresponding Worksheet objects to match."""
 
234
        
 
235
        worksheet_below = req.store.find(Worksheet,
 
236
            Worksheet.offering_id == self.context.id,
 
237
            Worksheet.identifier == unicode(worksheetid)).one()
 
238
        if worksheet_below is None:
 
239
            raise NotFound('worksheet_below')
 
240
        worksheet_above = req.store.find(Worksheet,
 
241
            Worksheet.offering_id == self.context.id,
 
242
            Worksheet.seq_no == (worksheet_below.seq_no - 1)).one()
 
243
        if worksheet_above is None:
 
244
            raise NotFound('worksheet_above')
 
245
 
 
246
        worksheet_below.seq_no = worksheet_below.seq_no - 1
 
247
        worksheet_above.seq_no = worksheet_above.seq_no + 1
 
248
        
 
249
        return {'result': 'ok'}
 
250
 
 
251
    @named_operation('edit')
 
252
    def move_down(self, req, worksheetid):
 
253
        """Takes a list of worksheet-seq_no pairs and updates their 
 
254
        corresponding Worksheet objects to match."""
 
255
        
 
256
        worksheet_above = req.store.find(Worksheet,
 
257
            Worksheet.offering_id == self.context.id,
 
258
            Worksheet.identifier == unicode(worksheetid)).one()
 
259
        if worksheet_above is None:
 
260
            raise NotFound('worksheet_below')
 
261
        worksheet_below = req.store.find(Worksheet,
 
262
            Worksheet.offering_id == self.context.id,
 
263
            Worksheet.seq_no == (worksheet_above.seq_no + 1)).one()
 
264
        if worksheet_below is None:
 
265
            raise NotFound('worksheet_above')
 
266
 
 
267
        worksheet_below.seq_no = worksheet_below.seq_no - 1
 
268
        worksheet_above.seq_no = worksheet_above.seq_no + 1
 
269
        
 
270
        return {'result': 'ok'}