← 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: 2010-02-26 10:44:48 UTC
  • Revision ID: coles.david@gmail.com-20100226104448-4d1r3qco3shgn1gk
Tags: 1.0rc2
https://launchpad.net/bugs/528211
console: Make sure HOME is set correctly (not always the same as CWD). Also use ivle.interpret.execute_raw rather than duplicating trapoline calling code in ivle.chat

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/webapp/tutorial/service.py
19
19
 
20
20
'''AJAX backend for the tutorial application.'''
21
21
 
22
 
import os
23
22
import datetime
24
23
 
25
 
import ivle.util
26
 
import ivle.console
 
24
import genshi
 
25
from storm.locals import Store
 
26
 
27
27
import ivle.database
28
 
import ivle.worksheet
29
 
import ivle.conf
30
 
import ivle.webapp.tutorial.test
31
 
 
32
 
from ivle.webapp.base.rest import JSONRESTView, named_operation
 
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, named_operation,
 
32
                                   require_permission)
33
33
from ivle.webapp.errors import NotFound
34
34
 
35
 
# If True, getattempts or getattempt will allow browsing of inactive/disabled
36
 
# attempts. If False, will not allow this.
37
 
HISTORY_ALLOW_INACTIVE = False
38
35
 
39
36
TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S'
40
37
 
41
38
 
42
39
class AttemptsRESTView(JSONRESTView):
43
40
    '''REST view of a user's attempts at an exercise.'''
44
 
    def __init__(self, req, subject, worksheet, exercise, username):
45
 
        # TODO: Find exercise within worksheet.
46
 
        self.user = ivle.database.User.get_by_login(req.store, username)
47
 
        if self.user is None:
48
 
            raise NotFound()
49
 
        self.exercise = exercise
50
41
 
 
42
    @require_permission('edit')
51
43
    def GET(self, req):
52
44
        """Handles a GET Attempts action."""
53
 
        exercise = ivle.database.Exercise.get_by_name(req.store, 
54
 
                                                        self.exercise)
55
 
 
56
 
        attempts = ivle.worksheet.get_exercise_attempts(req.store, self.user,
57
 
                            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)
58
48
        # attempts is a list of ExerciseAttempt objects. Convert to dictionaries
59
49
        time_fmt = lambda dt: datetime.datetime.strftime(dt, TIMESTAMP_FORMAT)
60
50
        attempts = [{'date': time_fmt(a.date), 'complete': a.complete}
63
53
        return attempts
64
54
 
65
55
 
 
56
    @require_permission('edit')
66
57
    def PUT(self, req, data):
67
 
        ''' Tests the given submission '''
68
 
        exercisefile = ivle.util.open_exercise_file(self.exercise)
69
 
        if exercisefile is None:
70
 
            raise NotFound()
71
 
 
72
 
        # Start a console to run the tests on
73
 
        jail_path = os.path.join(ivle.conf.jail_base, req.user.login)
74
 
        working_dir = os.path.join("/home", req.user.login)
75
 
        cons = ivle.console.Console(req.user.unixid, jail_path, working_dir)
76
 
 
77
 
        # Parse the file into a exercise object using the test suite
78
 
        exercise_obj = ivle.webapp.tutorial.test.parse_exercise_file(
79
 
                                                            exercisefile, cons)
80
 
        exercisefile.close()
81
 
 
82
 
        # Run the test cases. Get the result back as a JSONable object.
83
 
        # Return it.
84
 
        test_results = exercise_obj.run_tests(data['code'])
85
 
 
86
 
        # Close the console
87
 
        cons.close()
88
 
 
89
 
        # Get the Exercise from the database
90
 
        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'])
91
62
 
92
63
        attempt = ivle.database.ExerciseAttempt(user=req.user,
93
 
                                                exercise=exercise,
94
 
                                                date=datetime.datetime.now(),
95
 
                                                complete=test_results['passed'],
96
 
                                                # XXX
97
 
                                                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
        )
98
69
 
99
70
        req.store.add(attempt)
100
71
 
101
72
        # Query the DB to get an updated score on whether or not this problem
102
73
        # has EVER been completed (may be different from "passed", if it has
103
74
        # been completed before), and the total number of attempts.
104
 
        completed, attempts = ivle.worksheet.get_exercise_status(req.store,
105
 
            req.user, exercise)
 
75
        completed, attempts = ivle.worksheet.utils.get_exercise_status(
 
76
                req.store, req.user, self.context.worksheet_exercise)
106
77
        test_results["completed"] = completed
107
78
        test_results["attempts"] = attempts
108
79
 
112
83
class AttemptRESTView(JSONRESTView):
113
84
    '''REST view of an exercise attempt.'''
114
85
 
115
 
    def __init__(self, req, subject, worksheet, exercise, username, date):
116
 
        # TODO: Find exercise within worksheet.
117
 
        user = ivle.database.User.get_by_login(req.store, username)
118
 
        if user is None:
119
 
            raise NotFound()
120
 
 
121
 
        try:
122
 
            date = datetime.datetime.strptime(date, TIMESTAMP_FORMAT)
123
 
        except ValueError:
124
 
            raise NotFound()
125
 
 
126
 
        exercise = ivle.database.Exercise.get_by_name(req.store, exercise)
127
 
        attempt = ivle.worksheet.get_exercise_attempt(req.store, user,
128
 
            exercise, as_of=date, allow_inactive=HISTORY_ALLOW_INACTIVE)
129
 
 
130
 
        if attempt is None:
131
 
            raise NotFound()
132
 
 
133
 
        self.context = attempt
134
 
 
 
86
    @require_permission('view')
135
87
    def GET(self, req):
136
88
        return {'code': self.context.text}
137
89
 
138
90
 
139
 
class ExerciseRESTView(JSONRESTView):
140
 
    '''REST view of an exercise.'''
141
 
    @named_operation
 
91
class WorksheetExerciseRESTView(JSONRESTView):
 
92
    '''REST view of a worksheet exercise.'''
 
93
 
 
94
    @named_operation('view')
142
95
    def save(self, req, text):
143
 
        # Need to open JUST so we know this is a real exercise.
144
 
        # (This avoids users submitting code for bogus exercises).
145
 
        exercisefile = ivle.util.open_exercise_file(self.exercise)
146
 
        if exercisefile is None:
147
 
            raise NotFound()
148
 
        exercisefile.close()
149
 
 
150
 
        exercise = ivle.database.Exercise.get_by_name(req.store, self.exercise)
151
 
        ivle.worksheet.save_exercise(req.store, req.user, exercise,
152
 
                                     unicode(text), datetime.datetime.now())
 
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
 
153
115
        return {"result": "ok"}
 
116
 
 
117
 
 
118
class WorksheetsRESTView(JSONRESTView):
 
119
    """View used to update and create Worksheets."""
 
120
 
 
121
    @named_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
    @named_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'}