← 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: David Coles
  • Date: 2009-08-13 05:15:17 UTC
  • mto: (1294.2.124 ui-the-third)
  • mto: This revision was merged to the branch mainline in revision 1353.
  • Revision ID: coles.david@gmail.com-20090813051517-b5zxrzdt9rc8kxyv
Let the publisher generate help entry URLs for us.

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 problem boxes.
25
 
 
26
 
# Calling syntax
27
 
# Path must be empty.
28
 
# The arguments determine what is to be done on this file.
29
 
 
30
 
# "problem" - The path to a problem file (including the .xml extension),
31
 
#    relative to the subjects base directory.
32
 
# "code" - Full text of the student's code being submitted.
33
 
# "action". May be "test". (More to come).
34
 
 
35
 
# Returns a JSON response string indicating the results.
 
18
# Author: Matt Giuca, Nick Chadwick
 
19
 
 
20
'''AJAX backend for the tutorial application.'''
36
21
 
37
22
import os
38
 
 
39
 
import cjson
40
 
 
41
 
import test
42
 
import conf
43
 
 
44
 
def handle(req):
45
 
    """Handler for Ajax backend TutorialService app."""
46
 
    # Set request attributes
47
 
    req.write_html_head_foot = False     # No HTML
48
 
 
49
 
    if req.path != "":
50
 
        req.throw_error(req.HTTP_BAD_REQUEST)
51
 
    # Get all the arguments, if POST.
52
 
    # Ignore arguments if not POST, since we aren't allowed to cause
53
 
    # side-effects on the server.
54
 
    fields = req.get_fieldstorage()
55
 
    act = fields.getfirst('action')
56
 
    problem = fields.getfirst('problem')
57
 
    code = fields.getfirst('code')
58
 
 
59
 
    if problem == None or code == None or act == None:
60
 
        req.throw_error(req.HTTP_BAD_REQUEST)
61
 
    act = act.value
62
 
    problem = problem.value
63
 
    code = code.value
64
 
 
65
 
    if act == "test":
66
 
        handle_test(req, problem, code, fields)
67
 
    elif act == "run":
68
 
        handle_run(req, problem, code, fields)
69
 
    else:
70
 
        req.throw_error(req.HTTP_BAD_REQUEST)
71
 
 
72
 
def handle_test(req, problem, code, fields):
73
 
    """Handles a test action."""
74
 
 
75
 
    # First normalise the path
76
 
    problem = os.path.normpath(problem)
77
 
    # Now if it begins with ".." or separator, then it's illegal
78
 
    if problem.startswith("..") or problem.startswith(os.sep):
79
 
        problemfile = None
80
 
    else:
81
 
        problemfile = os.path.join(conf.problems_base, problem)
82
 
 
83
 
    try:
84
 
        problemfile = open(problemfile)
85
 
    except (TypeError, IOError):    # TypeError if problemfile == None
86
 
        req.throw_error(req.HTTP_NOT_FOUND)
87
 
 
88
 
    # Parse the file into a problem object using the test suite
89
 
    problem_obj = test.parse_tutorial_file(problemfile)
90
 
    problemfile.close()
91
 
    # Run the test cases. Get the result back as a JSONable object.
92
 
    # Return it.
93
 
    test_results = problem_obj.run_tests(code)
94
 
    req.write(cjson.encode(test_results))
95
 
 
96
 
def handle_run(req, problem, code, fields):
97
 
    """Handles a run action."""
98
 
    # Extremely makeshift.
99
 
    # For now, just echo the code back
100
 
    output = code
101
 
    out_json = {"stdout": output}
102
 
    req.write(cjson.encode(out_json))
 
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
 
37
 
 
38
 
 
39
TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S'
 
40
 
 
41
class AttemptsRESTView(JSONRESTView):
 
42
    '''REST view of a user's attempts at an exercise.'''
 
43
 
 
44
    @require_permission('edit')
 
45
    def GET(self, req):
 
46
        """Handles a GET Attempts action."""
 
47
        attempts = req.store.find(ExerciseAttempt, 
 
48
                ExerciseAttempt.ws_ex_id == self.context.worksheet_exercise.id,
 
49
                ExerciseAttempt.user_id == self.context.user.id)
 
50
        # attempts is a list of ExerciseAttempt objects. Convert to dictionaries
 
51
        time_fmt = lambda dt: datetime.datetime.strftime(dt, TIMESTAMP_FORMAT)
 
52
        attempts = [{'date': time_fmt(a.date), 'complete': a.complete}
 
53
                for a in attempts]
 
54
 
 
55
        return attempts
 
56
 
 
57
 
 
58
    @require_permission('edit')
 
59
    def PUT(self, req, data):
 
60
        """ Tests the given submission """
 
61
        # Start a console to run the tests on
 
62
        jail_path = os.path.join(req.config['paths']['jails']['mounts'],
 
63
                                 req.user.login)
 
64
        working_dir = os.path.join("/home", req.user.login)
 
65
        cons = ivle.console.Console(req.config, req.user.unixid, jail_path,
 
66
                                    working_dir)
 
67
 
 
68
        # Parse the file into a exercise object using the test suite
 
69
        exercise_obj = ivle.webapp.tutorial.test.parse_exercise_file(
 
70
                            self.context.worksheet_exercise.exercise, cons)
 
71
 
 
72
        # Run the test cases. Get the result back as a JSONable object.
 
73
        # Return it.
 
74
        test_results = exercise_obj.run_tests(data['code'])
 
75
 
 
76
        # Close the console
 
77
        cons.close()
 
78
 
 
79
        attempt = ivle.database.ExerciseAttempt(user=req.user,
 
80
            worksheet_exercise = self.context.worksheet_exercise,
 
81
            date = datetime.datetime.now(),
 
82
            complete = test_results['passed'],
 
83
            text = unicode(data['code'])
 
84
        )
 
85
 
 
86
        req.store.add(attempt)
 
87
 
 
88
        # Query the DB to get an updated score on whether or not this problem
 
89
        # has EVER been completed (may be different from "passed", if it has
 
90
        # been completed before), and the total number of attempts.
 
91
        completed, attempts = ivle.worksheet.utils.get_exercise_status(
 
92
                req.store, req.user, self.context.worksheet_exercise)
 
93
        test_results["completed"] = completed
 
94
        test_results["attempts"] = attempts
 
95
 
 
96
        return test_results
 
97
 
 
98
 
 
99
class AttemptRESTView(JSONRESTView):
 
100
    '''REST view of an exercise attempt.'''
 
101
 
 
102
    @require_permission('view')
 
103
    def GET(self, req):
 
104
        return {'code': self.context.text}
 
105
 
 
106
 
 
107
class WorksheetExerciseRESTView(JSONRESTView):
 
108
    '''REST view of a worksheet exercise.'''
 
109
 
 
110
    @named_operation('view')
 
111
    def save(self, req, text):
 
112
        # Find the appropriate WorksheetExercise to save to. If its not found,
 
113
        # the user is submitting against a non-existant worksheet/exercise
 
114
 
 
115
        old_save = req.store.find(ExerciseSave,
 
116
            ExerciseSave.ws_ex_id == self.context.id,
 
117
            ExerciseSave.user == req.user).one()
 
118
        
 
119
        #Overwrite the old, or create a new if there isn't one
 
120
        if old_save is None:
 
121
            new_save = ExerciseSave()
 
122
            req.store.add(new_save)
 
123
        else:
 
124
            new_save = old_save
 
125
        
 
126
        new_save.worksheet_exercise = self.context
 
127
        new_save.user = req.user
 
128
        new_save.text = unicode(text)
 
129
        new_save.date = datetime.datetime.now()
 
130
 
 
131
        return {"result": "ok"}
 
132
 
 
133
 
 
134
# Note that this is the view of an existing worksheet. Creation is handled
 
135
# by OfferingRESTView (as offerings have worksheets)
 
136
class WorksheetRESTView(JSONRESTView):
 
137
    """View used to update a worksheet."""
 
138
 
 
139
    @named_operation('edit')
 
140
    def save(self, req, name, assessable, data, format):
 
141
        """Takes worksheet data and saves it."""
 
142
        self.context.name = unicode(name)
 
143
        self.context.assessable = self.convert_bool(assessable)
 
144
        self.context.data = unicode(data)
 
145
        self.context.format = unicode(format)
 
146
        ivle.worksheet.utils.update_exerciselist(self.context)
 
147
        
 
148
        return {"result": "ok"}
 
149
 
 
150
class WorksheetsRESTView(JSONRESTView):
 
151
    """View used to update and create Worksheets."""
 
152
 
 
153
    @named_operation('edit')
 
154
    def add_worksheet(self, req, identifier, name, assessable, data, format):
 
155
        """Takes worksheet data and adds it."""
 
156
        
 
157
        new_worksheet = Worksheet()
 
158
        new_worksheet.seq_no = self.context.worksheets.count()
 
159
        # Setting new_worksheet.offering implicitly adds new_worksheet,
 
160
        # hence worksheets.count MUST be called above it
 
161
        new_worksheet.offering = self.context
 
162
        new_worksheet.identifier = unicode(identifier)
 
163
        new_worksheet.name = unicode(name)
 
164
        new_worksheet.assessable = self.convert_bool(assessable)
 
165
        new_worksheet.data = unicode(data)
 
166
        new_worksheet.format = unicode(format)
 
167
        
 
168
        # This call is added for clarity, as the worksheet is implicitly added.        
 
169
        req.store.add(new_worksheet)
 
170
 
 
171
        ivle.worksheet.utils.update_exerciselist(new_worksheet)
 
172
 
 
173
        return {"result": "ok"}
 
174
 
 
175
    @named_operation('edit')
 
176
    def move_up(self, req, worksheetid):
 
177
        """Takes a list of worksheet-seq_no pairs and updates their 
 
178
        corresponding Worksheet objects to match."""
 
179
        
 
180
        worksheet_below = req.store.find(Worksheet,
 
181
            Worksheet.offering_id == self.context.id,
 
182
            Worksheet.identifier == unicode(worksheetid)).one()
 
183
        if worksheet_below is None:
 
184
            raise NotFound('worksheet_below')
 
185
        worksheet_above = req.store.find(Worksheet,
 
186
            Worksheet.offering_id == self.context.id,
 
187
            Worksheet.seq_no == (worksheet_below.seq_no - 1)).one()
 
188
        if worksheet_above is None:
 
189
            raise NotFound('worksheet_above')
 
190
 
 
191
        worksheet_below.seq_no = worksheet_below.seq_no - 1
 
192
        worksheet_above.seq_no = worksheet_above.seq_no + 1
 
193
        
 
194
        return {'result': 'ok'}
 
195
 
 
196
    @named_operation('edit')
 
197
    def move_down(self, req, worksheetid):
 
198
        """Takes a list of worksheet-seq_no pairs and updates their 
 
199
        corresponding Worksheet objects to match."""
 
200
        
 
201
        worksheet_above = req.store.find(Worksheet,
 
202
            Worksheet.offering_id == self.context.id,
 
203
            Worksheet.identifier == unicode(worksheetid)).one()
 
204
        if worksheet_above is None:
 
205
            raise NotFound('worksheet_below')
 
206
        worksheet_below = req.store.find(Worksheet,
 
207
            Worksheet.offering_id == self.context.id,
 
208
            Worksheet.seq_no == (worksheet_above.seq_no + 1)).one()
 
209
        if worksheet_below is None:
 
210
            raise NotFound('worksheet_above')
 
211
 
 
212
        worksheet_below.seq_no = worksheet_below.seq_no - 1
 
213
        worksheet_above.seq_no = worksheet_above.seq_no + 1
 
214
        
 
215
        return {'result': 'ok'}