← 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

Updated the exercises to be loaded from the database, not a local file.

This updated fixes some things broken in my previous commit, and now
it should leave the worksheets in a viewable (not working) state.

I have also updated ivle-addexercise and the database schema to reflect
the schema of an exercise.

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
22
23
import datetime
23
24
 
24
 
import genshi
25
 
from storm.locals import Store
26
 
 
 
25
import ivle.util
 
26
import ivle.console
27
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,
 
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,
32
34
                                   require_permission)
33
35
from ivle.webapp.errors import NotFound
34
36
 
 
37
# If True, getattempts or getattempt will allow browsing of inactive/disabled
 
38
# attempts. If False, will not allow this.
 
39
HISTORY_ALLOW_INACTIVE = False
35
40
 
36
41
TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S'
37
42
 
38
43
 
39
44
class AttemptsRESTView(JSONRESTView):
40
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.
41
54
 
42
55
    @require_permission('edit')
43
56
    def GET(self, req):
44
57
        """Handles a GET Attempts action."""
 
58
        exercise = req.store.find(Exercise, Exercise.id == self.exercise).one()
 
59
 
45
60
        attempts = req.store.find(ExerciseAttempt, 
46
 
                ExerciseAttempt.ws_ex_id == self.context.worksheet_exercise.id,
47
 
                ExerciseAttempt.user_id == self.context.user.id)
 
61
                ExerciseAttempt.exercise_id == exercise.id,
 
62
                ExerciseAttempt.user_id == self.user.id)
48
63
        # attempts is a list of ExerciseAttempt objects. Convert to dictionaries
49
64
        time_fmt = lambda dt: datetime.datetime.strftime(dt, TIMESTAMP_FORMAT)
50
65
        attempts = [{'date': time_fmt(a.date), 'complete': a.complete}
56
71
    @require_permission('edit')
57
72
    def PUT(self, req, data):
58
73
        """ Tests the given submission """
59
 
        # Trim off any trailing whitespace (can cause syntax errors in python)
60
 
        # While technically this is a user error, it causes a lot of confusion 
61
 
        # for student since it's "invisible".
62
 
        code = data['code'].rstrip()
63
 
 
64
 
        test_results = ivle.worksheet.utils.test_exercise_submission(
65
 
            req.config, req.user, self.context.worksheet_exercise.exercise,
66
 
            code)
 
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()
67
93
 
68
94
        attempt = ivle.database.ExerciseAttempt(user=req.user,
69
 
            worksheet_exercise = self.context.worksheet_exercise,
70
 
            date = datetime.datetime.now(),
71
 
            complete = test_results['passed'],
72
 
            text = unicode(code)
73
 
        )
 
95
                                                exercise=exercise,
 
96
                                                date=datetime.datetime.now(),
 
97
                                                complete=test_results['passed'],
 
98
                                                # XXX
 
99
                                                text=unicode(data['code']))
74
100
 
75
101
        req.store.add(attempt)
76
102
 
77
103
        # Query the DB to get an updated score on whether or not this problem
78
104
        # has EVER been completed (may be different from "passed", if it has
79
105
        # been completed before), and the total number of attempts.
80
 
        completed, attempts = ivle.worksheet.utils.get_exercise_status(
81
 
                req.store, req.user, self.context.worksheet_exercise)
 
106
        completed, attempts = ivle.worksheet.get_exercise_status(req.store,
 
107
            req.user, exercise)
82
108
        test_results["completed"] = completed
83
109
        test_results["attempts"] = attempts
84
110
 
88
114
class AttemptRESTView(JSONRESTView):
89
115
    '''REST view of an exercise attempt.'''
90
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
 
91
137
    @require_permission('view')
92
138
    def GET(self, req):
93
139
        return {'code': self.context.text}
94
140
 
95
141
 
96
 
class WorksheetExerciseRESTView(JSONRESTView):
97
 
    '''REST view of a worksheet exercise.'''
98
 
 
99
 
    @write_operation('view')
 
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')
100
153
    def save(self, req, text):
101
 
        # Find the appropriate WorksheetExercise to save to. If its not found,
102
 
        # the user is submitting against a non-existant worksheet/exercise
103
 
 
104
 
        old_save = req.store.find(ExerciseSave,
105
 
            ExerciseSave.ws_ex_id == self.context.id,
106
 
            ExerciseSave.user == req.user).one()
107
 
        
108
 
        #Overwrite the old, or create a new if there isn't one
109
 
        if old_save is None:
110
 
            new_save = ExerciseSave()
111
 
            req.store.add(new_save)
112
 
        else:
113
 
            new_save = old_save
114
 
        
115
 
        new_save.worksheet_exercise = self.context
116
 
        new_save.user = req.user
117
 
        new_save.text = unicode(text)
118
 
        new_save.date = datetime.datetime.now()
119
 
 
 
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())
120
160
        return {"result": "ok"}
121
 
 
122
 
 
123
 
class WorksheetsRESTView(JSONRESTView):
124
 
    """View used to update and create Worksheets."""
125
 
 
126
 
    @write_operation('edit_worksheets')
127
 
    def move_up(self, req, worksheetid):
128
 
        """Takes a list of worksheet-seq_no pairs and updates their 
129
 
        corresponding Worksheet objects to match."""
130
 
        
131
 
        worksheet_below = req.store.find(Worksheet,
132
 
            Worksheet.offering_id == self.context.id,
133
 
            Worksheet.identifier == unicode(worksheetid)).one()
134
 
        if worksheet_below is None:
135
 
            raise NotFound('worksheet_below')
136
 
        worksheet_above = req.store.find(Worksheet,
137
 
            Worksheet.offering_id == self.context.id,
138
 
            Worksheet.seq_no == (worksheet_below.seq_no - 1)).one()
139
 
        if worksheet_above is None:
140
 
            raise NotFound('worksheet_above')
141
 
 
142
 
        worksheet_below.seq_no = worksheet_below.seq_no - 1
143
 
        worksheet_above.seq_no = worksheet_above.seq_no + 1
144
 
        
145
 
        return {'result': 'ok'}
146
 
 
147
 
    @write_operation('edit_worksheets')
148
 
    def move_down(self, req, worksheetid):
149
 
        """Takes a list of worksheet-seq_no pairs and updates their 
150
 
        corresponding Worksheet objects to match."""
151
 
        
152
 
        worksheet_above = req.store.find(Worksheet,
153
 
            Worksheet.offering_id == self.context.id,
154
 
            Worksheet.identifier == unicode(worksheetid)).one()
155
 
        if worksheet_above is None:
156
 
            raise NotFound('worksheet_below')
157
 
        worksheet_below = req.store.find(Worksheet,
158
 
            Worksheet.offering_id == self.context.id,
159
 
            Worksheet.seq_no == (worksheet_above.seq_no + 1)).one()
160
 
        if worksheet_below is None:
161
 
            raise NotFound('worksheet_above')
162
 
 
163
 
        worksheet_below.seq_no = worksheet_below.seq_no - 1
164
 
        worksheet_above.seq_no = worksheet_above.seq_no + 1
165
 
        
166
 
        return {'result': 'ok'}