← 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: 2010-07-20 04:52:31 UTC
  • mto: This revision was merged to the branch mainline in revision 1826.
  • Revision ID: grantw@unimelb.edu.au-20100720045231-8ia3uk8nao8zdq1i
Replace cjson with json, or simplejson if json is not available (Python <2.6)

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.
43
 
 
44
 
import os
45
 
import time
 
18
# Author: Matt Giuca, Nick Chadwick
 
19
 
 
20
'''AJAX backend for the tutorial application.'''
 
21
 
46
22
import datetime
47
23
 
48
 
import cjson
49
 
 
50
 
from ivle import util
51
 
from ivle import console
52
 
import ivle.database
53
 
import ivle.worksheet
54
 
import ivle.conf
55
 
import ivle.webapp.tutorial.test # XXX: Really .test, not real test.
56
 
 
57
 
from ivle.webapp.base.rest import JSONRESTView
58
 
import ivle.database
59
 
from ivle.webapp.base.rest import named_operation
60
 
 
61
 
# If True, getattempts or getattempt will allow browsing of inactive/disabled
62
 
# attempts. If False, will not allow this.
63
 
HISTORY_ALLOW_INACTIVE = False
 
24
import genshi
 
25
from storm.locals import Store
 
26
 
 
27
import ivle.database
 
28
from ivle.database import Exercise, ExerciseAttempt, ExerciseSave, Worksheet, \
 
29
                          Offering, Subject, Semester, User, WorksheetExercise
 
30
import ivle.worksheet.utils
 
31
from ivle.webapp.base.rest import (JSONRESTView, write_operation,
 
32
                                   require_permission)
 
33
from ivle.webapp.errors import NotFound
 
34
 
64
35
 
65
36
TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S'
66
37
 
67
38
 
68
39
class AttemptsRESTView(JSONRESTView):
69
 
    '''
70
 
    Class to return a list of attempts for a given exercise, or add an Attempt
71
 
    '''
 
40
    '''REST view of a user's attempts at an exercise.'''
 
41
 
 
42
    @require_permission('edit')
72
43
    def GET(self, req):
73
44
        """Handles a GET Attempts action."""
74
 
        exercise = ivle.database.Exercise.get_by_name(req.store, 
75
 
                                                        self.exercise)
76
 
        user = ivle.database.User.get_by_login(req.store, self.username)
77
 
 
78
 
        attempts = ivle.worksheet.get_exercise_attempts(req.store, user,
79
 
                            exercise, allow_inactive=HISTORY_ALLOW_INACTIVE)
 
45
        attempts = req.store.find(ExerciseAttempt, 
 
46
                ExerciseAttempt.ws_ex_id == self.context.worksheet_exercise.id,
 
47
                ExerciseAttempt.user_id == self.context.user.id)
80
48
        # attempts is a list of ExerciseAttempt objects. Convert to dictionaries
81
49
        time_fmt = lambda dt: datetime.datetime.strftime(dt, TIMESTAMP_FORMAT)
82
50
        attempts = [{'date': time_fmt(a.date), 'complete': a.complete}
83
51
                for a in attempts]
84
 
                
 
52
 
85
53
        return attempts
86
 
        
 
54
 
 
55
 
 
56
    @require_permission('edit')
87
57
    def PUT(self, req, data):
88
 
        ''' Tests the given submission '''
89
 
        exercisefile = util.open_exercise_file(self.exercise)
90
 
        if exercisefile is None:
91
 
            req.throw_error(req.HTTP_NOT_FOUND,
92
 
                "The exercise was not found.")
93
 
 
94
 
        # Start a console to run the tests on
95
 
        jail_path = os.path.join(ivle.conf.jail_base, req.user.login)
96
 
        working_dir = os.path.join("/home", req.user.login)
97
 
        cons = console.Console(req.user.unixid, jail_path, working_dir)
98
 
 
99
 
        # Parse the file into a exercise object using the test suite
100
 
        exercise_obj = ivle.webapp.tutorial.test.parse_exercise_file(
101
 
                                                            exercisefile, cons)
102
 
        exercisefile.close()
103
 
 
104
 
        # Run the test cases. Get the result back as a JSONable object.
105
 
        # Return it.
106
 
        test_results = exercise_obj.run_tests(data['code'])
107
 
 
108
 
        # Close the console
109
 
        cons.close()
110
 
 
111
 
        # Get the Exercise from the database
112
 
        exercise = ivle.database.Exercise.get_by_name(req.store, self.exercise)
 
58
        """ Tests the given submission """
 
59
        test_results = ivle.worksheet.utils.test_exercise_submission(
 
60
            req.config, req.user, self.context.worksheet_exercise.exercise,
 
61
            data['code'])
113
62
 
114
63
        attempt = ivle.database.ExerciseAttempt(user=req.user,
115
 
                                                exercise=exercise,
116
 
                                                date=datetime.datetime.now(),
117
 
                                                complete=test_results['passed'],
118
 
                                                # XXX
119
 
                                                text=unicode(data['code']))
 
64
            worksheet_exercise = self.context.worksheet_exercise,
 
65
            date = datetime.datetime.now(),
 
66
            complete = test_results['passed'],
 
67
            text = unicode(data['code'])
 
68
        )
120
69
 
121
70
        req.store.add(attempt)
122
 
        req.store.commit()
 
71
 
123
72
        # Query the DB to get an updated score on whether or not this problem
124
73
        # has EVER been completed (may be different from "passed", if it has
125
74
        # been completed before), and the total number of attempts.
126
 
        completed, attempts = ivle.worksheet.get_exercise_status(req.store,
127
 
            req.user, exercise)
 
75
        completed, attempts = ivle.worksheet.utils.get_exercise_status(
 
76
                req.store, req.user, self.context.worksheet_exercise)
128
77
        test_results["completed"] = completed
129
78
        test_results["attempts"] = attempts
130
79
 
131
80
        return test_results
132
 
        
 
81
 
133
82
 
134
83
class AttemptRESTView(JSONRESTView):
135
 
    '''
136
 
    View used to extract the data of a specified attempt
137
 
    '''
138
 
    
 
84
    '''REST view of an exercise attempt.'''
 
85
 
 
86
    @require_permission('view')
139
87
    def GET(self, req):
140
 
        # Get an actual date object, rather than a string
141
 
        date = datetime.datetime.strptime(self.date, TIMESTAMP_FORMAT)
142
 
        
143
 
        exercise = ivle.database.Exercise.get_by_name(req.store, self.exercise)
144
 
        attempt = ivle.worksheet.get_exercise_attempt(req.store, req.user,
145
 
            exercise, as_of=date, allow_inactive=HISTORY_ALLOW_INACTIVE)
146
 
        if attempt is not None:
147
 
            attempt = attempt.text
148
 
        # attempt may be None; will write "null"
149
 
        return {'code': attempt}
150
 
        
151
 
class ExerciseRESTView(JSONRESTView):
152
 
    '''
153
 
    Handles a save action. This saves the user's code without executing it.
154
 
    '''
155
 
    @named_operation
 
88
        return {'code': self.context.text}
 
89
 
 
90
 
 
91
class WorksheetExerciseRESTView(JSONRESTView):
 
92
    '''REST view of a worksheet exercise.'''
 
93
 
 
94
    @write_operation('view')
156
95
    def save(self, req, text):
157
 
        # Need to open JUST so we know this is a real exercise.
158
 
        # (This avoids users submitting code for bogus exercises).
159
 
        exercisefile = util.open_exercise_file(self.exercise)
160
 
        if exercisefile is None:
161
 
            req.throw_error(req.HTTP_NOT_FOUND,
162
 
                "The exercise was not found.")
163
 
        exercisefile.close()
164
 
 
165
 
        exercise = ivle.database.Exercise.get_by_name(req.store, self.exercise)
166
 
        ivle.worksheet.save_exercise(req.store, req.user, exercise,
167
 
                                     unicode(text), datetime.datetime.now())
168
 
        req.store.commit()
 
96
        # Find the appropriate WorksheetExercise to save to. If its not found,
 
97
        # the user is submitting against a non-existant worksheet/exercise
 
98
 
 
99
        old_save = req.store.find(ExerciseSave,
 
100
            ExerciseSave.ws_ex_id == self.context.id,
 
101
            ExerciseSave.user == req.user).one()
 
102
        
 
103
        #Overwrite the old, or create a new if there isn't one
 
104
        if old_save is None:
 
105
            new_save = ExerciseSave()
 
106
            req.store.add(new_save)
 
107
        else:
 
108
            new_save = old_save
 
109
        
 
110
        new_save.worksheet_exercise = self.context
 
111
        new_save.user = req.user
 
112
        new_save.text = unicode(text)
 
113
        new_save.date = datetime.datetime.now()
 
114
 
169
115
        return {"result": "ok"}
 
116
 
 
117
 
 
118
class WorksheetsRESTView(JSONRESTView):
 
119
    """View used to update and create Worksheets."""
 
120
 
 
121
    @write_operation('edit_worksheets')
 
122
    def move_up(self, req, worksheetid):
 
123
        """Takes a list of worksheet-seq_no pairs and updates their 
 
124
        corresponding Worksheet objects to match."""
 
125
        
 
126
        worksheet_below = req.store.find(Worksheet,
 
127
            Worksheet.offering_id == self.context.id,
 
128
            Worksheet.identifier == unicode(worksheetid)).one()
 
129
        if worksheet_below is None:
 
130
            raise NotFound('worksheet_below')
 
131
        worksheet_above = req.store.find(Worksheet,
 
132
            Worksheet.offering_id == self.context.id,
 
133
            Worksheet.seq_no == (worksheet_below.seq_no - 1)).one()
 
134
        if worksheet_above is None:
 
135
            raise NotFound('worksheet_above')
 
136
 
 
137
        worksheet_below.seq_no = worksheet_below.seq_no - 1
 
138
        worksheet_above.seq_no = worksheet_above.seq_no + 1
 
139
        
 
140
        return {'result': 'ok'}
 
141
 
 
142
    @write_operation('edit_worksheets')
 
143
    def move_down(self, req, worksheetid):
 
144
        """Takes a list of worksheet-seq_no pairs and updates their 
 
145
        corresponding Worksheet objects to match."""
 
146
        
 
147
        worksheet_above = req.store.find(Worksheet,
 
148
            Worksheet.offering_id == self.context.id,
 
149
            Worksheet.identifier == unicode(worksheetid)).one()
 
150
        if worksheet_above is None:
 
151
            raise NotFound('worksheet_below')
 
152
        worksheet_below = req.store.find(Worksheet,
 
153
            Worksheet.offering_id == self.context.id,
 
154
            Worksheet.seq_no == (worksheet_above.seq_no + 1)).one()
 
155
        if worksheet_below is None:
 
156
            raise NotFound('worksheet_above')
 
157
 
 
158
        worksheet_below.seq_no = worksheet_below.seq_no - 1
 
159
        worksheet_above.seq_no = worksheet_above.seq_no + 1
 
160
        
 
161
        return {'result': 'ok'}