← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to ivle/webapp/base/rest.py

Modified the database so that exercises are now stored in the database, rather
than in flat files.

This also necessitated adding new tables and storm classes for test suites
and test cases.

Note that this commit merely changes the database and adds a script to
upload exercises. The code for actually reading exercises has yet
to be changed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/webapp/base/rest.py
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
 
# Author: Matt Giuca, Will Grant, Nick Chadwick
 
18
# Author: Matt Giuca, Will Grant
19
19
 
20
20
import cgi
21
 
import functools
22
21
import inspect
23
 
import os
24
 
import urlparse
25
 
 
26
 
try:
27
 
    import json
28
 
except ImportError:
29
 
    import simplejson as json
30
 
 
31
 
import genshi.template
 
22
 
 
23
import cjson
32
24
 
33
25
from ivle.webapp.base.views import BaseView
34
 
from ivle.webapp.base.xhtml import GenshiLoaderMixin
35
26
from ivle.webapp.errors import BadRequest, MethodNotAllowed, Unauthorized
36
27
 
37
28
class RESTView(BaseView):
41
32
    """
42
33
    content_type = "application/octet-stream"
43
34
 
 
35
    def __init__(self, req, *args, **kwargs):
 
36
        for key in kwargs:
 
37
            setattr(self, key, kwargs[key])
 
38
 
44
39
    def render(self, req):
45
40
        raise NotImplementedError()
46
41
 
61
56
        if not hasattr(op, '_rest_api_permission'):
62
57
            raise Unauthorized()
63
58
 
64
 
        if (op._rest_api_permission not in
65
 
            self.get_permissions(req.user, req.config)):
 
59
        if op._rest_api_permission not in self.get_permissions(req.user):
66
60
            raise Unauthorized()
67
 
    
68
 
    def convert_bool(self, value):
69
 
        if value in ('True', 'true', True):
70
 
            return True
71
 
        elif value in ('False', 'false', False):
72
 
            return False
73
 
        else:
74
 
            raise BadRequest()
75
61
 
76
62
    def render(self, req):
77
63
        if req.method not in self._allowed_methods:
78
64
            raise MethodNotAllowed(allowed=self._allowed_methods)
79
65
 
80
66
        if req.method == 'GET':
81
 
            qargs = dict(cgi.parse_qsl(
82
 
                urlparse.urlparse(req.unparsed_uri).query,
83
 
                keep_blank_values=1))
84
 
            if 'ivle.op' in qargs:
85
 
                outjson = self._named_operation(req, qargs, readonly=True)
86
 
            else:
87
 
                self.authorize_method(req, self.GET)
88
 
                outjson = self.GET(req)
 
67
            self.authorize_method(req, self.GET)
 
68
            outjson = self.GET(req)
89
69
        # Since PATCH isn't yet an official HTTP method, we allow users to
90
70
        # turn a PUT into a PATCH by supplying a special header.
91
71
        elif req.method == 'PATCH' or (req.method == 'PUT' and
93
73
              req.headers_in['X-IVLE-Patch-Semantics'].lower() == 'yes'):
94
74
            self.authorize_method(req, self.PATCH)
95
75
            try:
96
 
                input = json.loads(req.read())
97
 
            except ValueError:
 
76
                input = cjson.decode(req.read())
 
77
            except cjson.DecodeError:
98
78
                raise BadRequest('Invalid JSON data')
99
79
            outjson = self.PATCH(req, input)
100
80
        elif req.method == 'PUT':
101
81
            self.authorize_method(req, self.PUT)
102
82
            try:
103
 
                input = json.loads(req.read())
104
 
            except ValueError:
 
83
                input = cjson.decode(req.read())
 
84
            except cjson.DecodeError:
105
85
                raise BadRequest('Invalid JSON data')
106
86
            outjson = self.PUT(req, input)
107
87
        # POST implies named operation.
108
88
        elif req.method == 'POST':
109
89
            # TODO: Check Content-Type and implement multipart/form-data.
110
 
            data = req.read()
111
 
            opargs = dict(cgi.parse_qsl(data, keep_blank_values=1))
112
 
            outjson = self._named_operation(req, opargs)
 
90
            opargs = dict(cgi.parse_qsl(req.read()))
 
91
            try:
 
92
                opname = opargs['ivle.op']
 
93
                del opargs['ivle.op']
 
94
            except KeyError:
 
95
                raise BadRequest('No named operation specified.')
 
96
 
 
97
            try:
 
98
                op = getattr(self, opname)
 
99
            except AttributeError:
 
100
                raise BadRequest('Invalid named operation.')
 
101
 
 
102
            if not hasattr(op, '_rest_api_callable') or \
 
103
               not op._rest_api_callable:
 
104
                raise BadRequest('Invalid named operation.')
 
105
 
 
106
            self.authorize_method(req, op)
 
107
 
 
108
            # Find any missing arguments, except for the first two (self, req)
 
109
            (args, vaargs, varkw, defaults) = inspect.getargspec(op)
 
110
            args = args[2:]
 
111
 
 
112
            # To find missing arguments, we eliminate the provided arguments
 
113
            # from the set of remaining function signature arguments. If the
 
114
            # remaining signature arguments are in the args[-len(defaults):],
 
115
            # we are OK.
 
116
            unspec = set(args) - set(opargs.keys())
 
117
            if unspec and not defaults:
 
118
                raise BadRequest('Missing arguments: ' + ', '.join(unspec))
 
119
 
 
120
            unspec = [k for k in unspec if k not in args[-len(defaults):]]
 
121
 
 
122
            if unspec:
 
123
                raise BadRequest('Missing arguments: ' + ', '.join(unspec))
 
124
 
 
125
            # We have extra arguments if the are no match args in the function
 
126
            # signature, AND there is no **.
 
127
            extra = set(opargs.keys()) - set(args)
 
128
            if extra and not varkw:
 
129
                raise BadRequest('Extra arguments: ' + ', '.join(extra))
 
130
 
 
131
            outjson = op(req, **opargs)
113
132
 
114
133
        req.content_type = self.content_type
115
 
        self.write_json(req, outjson)
116
 
 
117
 
    #This is a separate function to allow additional data to be passed through
118
 
    def write_json(self, req, outjson):
119
134
        if outjson is not None:
120
 
            req.write(json.dumps(outjson))
 
135
            req.write(cjson.encode(outjson))
121
136
            req.write("\n")
122
137
 
123
 
    def _named_operation(self, req, opargs, readonly=False):
124
 
        try:
125
 
            opname = opargs['ivle.op']
126
 
            del opargs['ivle.op']
127
 
        except KeyError:
128
 
            raise BadRequest('No named operation specified.')
129
 
 
130
 
        try:
131
 
            op = getattr(self, opname)
132
 
        except AttributeError:
133
 
            raise BadRequest('Invalid named operation.')
134
 
 
135
 
        if not hasattr(op, '_rest_api_callable') or \
136
 
           not op._rest_api_callable:
137
 
            raise BadRequest('Invalid named operation.')
138
 
 
139
 
        if readonly and op._rest_api_write_operation:
140
 
            raise BadRequest('POST required for write operation.')
141
 
 
142
 
        self.authorize_method(req, op)
143
 
 
144
 
        # Find any missing arguments, except for the first two (self, req)
145
 
        (args, vaargs, varkw, defaults) = inspect.getargspec(op)
146
 
        args = args[2:]
147
 
 
148
 
        # To find missing arguments, we eliminate the provided arguments
149
 
        # from the set of remaining function signature arguments. If the
150
 
        # remaining signature arguments are in the args[-len(defaults):],
151
 
        # we are OK.
152
 
        unspec = set(args) - set(opargs.keys())
153
 
        if unspec and not defaults:
154
 
            raise BadRequest('Missing arguments: ' + ', '.join(unspec))
155
 
 
156
 
        unspec = [k for k in unspec if k not in args[-len(defaults):]]
157
 
 
158
 
        if unspec:
159
 
            raise BadRequest('Missing arguments: ' + ', '.join(unspec))
160
 
 
161
 
        # We have extra arguments if the are no match args in the function
162
 
        # signature, AND there is no **.
163
 
        extra = set(opargs.keys()) - set(args)
164
 
        if extra and not varkw:
165
 
            raise BadRequest('Extra arguments: ' + ', '.join(extra))
166
 
 
167
 
        return op(req, **opargs)
168
 
 
169
 
 
170
 
class XHTMLRESTView(GenshiLoaderMixin, JSONRESTView):
171
 
    """A special type of RESTView which takes enhances the standard JSON
172
 
    with genshi XHTML functions.
173
 
    
174
 
    XHTMLRESTViews should have a template, which is rendered using their
175
 
    context. This is returned in the JSON as 'html'"""
176
 
    template = None
177
 
    ctx = genshi.template.Context()
178
 
 
179
 
    def render_fragment(self):
180
 
        if self.template is None:
181
 
            raise NotImplementedError()
182
 
 
183
 
        rest_template = os.path.join(os.path.dirname(
184
 
                inspect.getmodule(self).__file__), self.template)
185
 
        tmpl = self._loader.load(rest_template)
186
 
 
187
 
        return tmpl.generate(self.ctx).render('xhtml', doctype='xhtml')
188
 
    
189
 
    # This renders the template and adds it to the json
190
 
    def write_json(self, req, outjson):
191
 
        outjson["html"] = self.render_fragment()
192
 
        req.write(json.dumps(outjson))
193
 
        req.write("\n")
194
 
 
195
 
class _named_operation(object):
 
138
class named_operation(object):
196
139
    '''Declare a function to be accessible to HTTP users via the REST API.
197
140
    '''
198
 
    def __init__(self, write_operation, permission):
199
 
        self.write_operation = write_operation
 
141
    def __init__(self, permission):
200
142
        self.permission = permission
201
143
 
202
144
    def __call__(self, func):
203
145
        func._rest_api_callable = True
204
 
        func._rest_api_write_operation = self.write_operation
205
146
        func._rest_api_permission = self.permission
206
147
        return func
207
148
 
208
 
write_operation = functools.partial(_named_operation, True)
209
 
read_operation = functools.partial(_named_operation, False)
210
 
 
211
149
class require_permission(object):
212
150
    '''Declare the permission required for use of a method via the REST API.
213
151
    '''
217
155
    def __call__(self, func):
218
156
        func._rest_api_permission = self.permission
219
157
        return func
 
158