← 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-02-18 02:02:06 UTC
  • mto: (1092.1.63 setup-stuff)
  • mto: This revision was merged to the branch mainline in revision 1100.
  • Revision ID: grantw@unimelb.edu.au-20090218020206-3rguobhjx8k7ue26
Add documentation and patches for phpBB3 integration.

Drop the phpBB3 database dumps, as the administrator should run the
installation procedure.

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, console)
50
 
import test
51
 
import conf
 
23
import datetime
 
24
 
 
25
import ivle.util
 
26
import ivle.console
 
27
import ivle.database
 
28
from ivle.database import Exercise, ExerciseAttempt, ExerciseSave
 
29
import ivle.worksheet
 
30
import ivle.conf
 
31
import ivle.webapp.tutorial.test
 
32
 
 
33
from ivle.webapp.base.rest import (JSONRESTView, named_operation,
 
34
                                   require_permission)
 
35
from ivle.webapp.errors import NotFound
52
36
 
53
37
# If True, getattempts or getattempt will allow browsing of inactive/disabled
54
38
# attempts. If False, will not allow this.
55
39
HISTORY_ALLOW_INACTIVE = False
56
40
 
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.
107
 
    """
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
 
    # Start a console to run the tests on
138
 
    jail_path = os.path.join(conf.jail_base, req.user.login)
139
 
    working_dir = os.path.join("/home", req.user.login)
140
 
    cons = console.Console(req.user.unixid, jail_path, working_dir)
141
 
 
142
 
    # Parse the file into a exercise object using the test suite
143
 
    exercise_obj = test.parse_exercise_file(exercisefile, cons)
144
 
    exercisefile.close()
145
 
 
146
 
    # Run the test cases. Get the result back as a JSONable object.
147
 
    # Return it.
148
 
    test_results = exercise_obj.run_tests(code)
149
 
 
150
 
    # Close the console
151
 
    cons.close()
152
 
 
153
 
    conn = db.DB()
154
 
    try:
155
 
        conn.insert_problem_attempt(
156
 
            login = req.user.login,
157
 
            exercisename = exercise,
158
 
            date = time.localtime(),
159
 
            complete = test_results['passed'],
160
 
            attempt = code)
 
41
TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S'
 
42
 
 
43
 
 
44
class AttemptsRESTView(JSONRESTView):
 
45
    '''REST view of a user's attempts at an exercise.'''
 
46
    def __init__(self, req, subject, year, semester, worksheet, 
 
47
                                                exercise, username):
 
48
        self.user = ivle.database.User.get_by_login(req.store, username)
 
49
        if self.user is None:
 
50
            raise NotFound()
 
51
        self.exercise = exercise
 
52
        
 
53
        self.context = self.user # XXX: Not quite right.
 
54
 
 
55
    @require_permission('edit')
 
56
    def GET(self, req):
 
57
        """Handles a GET Attempts action."""
 
58
        exercise = req.store.find(Exercise, Exercise.id == self.exercise).one()
 
59
 
 
60
        attempts = req.store.find(ExerciseAttempt, 
 
61
                ExerciseAttempt.exercise_id == exercise.id,
 
62
                ExerciseAttempt.user_id == self.user.id)
 
63
        # attempts is a list of ExerciseAttempt objects. Convert to dictionaries
 
64
        time_fmt = lambda dt: datetime.datetime.strftime(dt, TIMESTAMP_FORMAT)
 
65
        attempts = [{'date': time_fmt(a.date), 'complete': a.complete}
 
66
                for a in attempts]
 
67
 
 
68
        return attempts
 
69
 
 
70
 
 
71
    @require_permission('edit')
 
72
    def PUT(self, req, data):
 
73
        """ Tests the given submission """
 
74
        exercise = req.store.find(Exercise, Exercise.id == self.exercise).one()
 
75
        if exercise is None:
 
76
            raise NotFound()
 
77
 
 
78
        # Start a console to run the tests on
 
79
        jail_path = os.path.join(ivle.conf.jail_base, req.user.login)
 
80
        working_dir = os.path.join("/home", req.user.login)
 
81
        cons = ivle.console.Console(req.user.unixid, jail_path, working_dir)
 
82
 
 
83
        # Parse the file into a exercise object using the test suite
 
84
        exercise_obj = ivle.webapp.tutorial.test.parse_exercise_file(
 
85
                                                            exercise, cons)
 
86
 
 
87
        # Run the test cases. Get the result back as a JSONable object.
 
88
        # Return it.
 
89
        test_results = exercise_obj.run_tests(data['code'])
 
90
 
 
91
        # Close the console
 
92
        cons.close()
 
93
 
 
94
        attempt = ivle.database.ExerciseAttempt(user=req.user,
 
95
                                                exercise=exercise,
 
96
                                                date=datetime.datetime.now(),
 
97
                                                complete=test_results['passed'],
 
98
                                                # XXX
 
99
                                                text=unicode(data['code']))
 
100
 
 
101
        req.store.add(attempt)
161
102
 
162
103
        # Query the DB to get an updated score on whether or not this problem
163
104
        # has EVER been completed (may be different from "passed", if it has
164
105
        # been completed before), and the total number of attempts.
165
 
        completed, attempts = conn.get_problem_status(req.user.login,
166
 
            exercise)
 
106
        completed, attempts = ivle.worksheet.get_exercise_status(req.store,
 
107
            req.user, exercise)
167
108
        test_results["completed"] = completed
168
109
        test_results["attempts"] = attempts
169
110
 
170
 
        req.write(cjson.encode(test_results))
171
 
    finally:
172
 
        conn.close()
173
 
 
174
 
def handle_getattempts(req, exercise):
175
 
    """Handles a getattempts action."""
176
 
    conn = db.DB()
177
 
    try:
178
 
        attempts = conn.get_problem_attempts(
179
 
            login=req.user.login,
180
 
            exercisename=exercise,
181
 
            allow_inactive=HISTORY_ALLOW_INACTIVE)
182
 
        req.write(cjson.encode(attempts))
183
 
    finally:
184
 
        conn.close()
185
 
 
186
 
def handle_getattempt(req, exercise, date):
187
 
    """Handles a getattempts action. Date is a struct_time."""
188
 
    conn = db.DB()
189
 
    try:
190
 
        attempt = conn.get_problem_attempt(
191
 
            login=req.user.login,
192
 
            exercisename=exercise,
193
 
            as_of=date,
194
 
            allow_inactive=HISTORY_ALLOW_INACTIVE)
195
 
        # attempt may be None; will write "null"
196
 
        req.write(cjson.encode(attempt))
197
 
    finally:
198
 
        conn.close()
 
111
        return test_results
 
112
 
 
113
 
 
114
class AttemptRESTView(JSONRESTView):
 
115
    '''REST view of an exercise attempt.'''
 
116
 
 
117
    def __init__(self, req, subject, worksheet, exercise, username, date):
 
118
        # TODO: Find exercise within worksheet.
 
119
        user = ivle.database.User.get_by_login(req.store, username)
 
120
        if user is None:
 
121
            raise NotFound()
 
122
 
 
123
        try:
 
124
            date = datetime.datetime.strptime(date, TIMESTAMP_FORMAT)
 
125
        except ValueError:
 
126
            raise NotFound()
 
127
 
 
128
        exercise = ivle.database.Exercise.get_by_name(req.store, exercise)
 
129
        attempt = ivle.worksheet.get_exercise_attempt(req.store, user,
 
130
            exercise, as_of=date, allow_inactive=HISTORY_ALLOW_INACTIVE)
 
131
 
 
132
        if attempt is None:
 
133
            raise NotFound()
 
134
 
 
135
        self.context = attempt
 
136
 
 
137
    @require_permission('view')
 
138
    def GET(self, req):
 
139
        return {'code': self.context.text}
 
140
 
 
141
 
 
142
class ExerciseRESTView(JSONRESTView):
 
143
    '''REST view of an exercise.'''
 
144
 
 
145
    def get_permissions(self, user):
 
146
        # XXX: Do it properly.
 
147
        if user is not None:
 
148
            return set(['save'])
 
149
        else:
 
150
            return set()
 
151
 
 
152
    @named_operation('save')
 
153
    def save(self, req, text):
 
154
        # Need to open JUST so we know this is a real exercise.
 
155
        # (This avoids users submitting code for bogus exercises).
 
156
        exercise = req.store.find(Exercise,
 
157
            Exercise.id == self.exercise).one()
 
158
        ivle.worksheet.save_exercise(req.store, req.user, exercise,
 
159
                                     unicode(text), datetime.datetime.now())
 
160
        return {"result": "ok"}