← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ivle/dispatch/request.py

  • Committer: chadnickbok
  • Date: 2009-01-22 02:14:14 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:1173
Fixes Issue #14

When uploading files, students will now be shown an
error message if there upload would replace already existing
files.

This upload will not be performed until it will not clobber
any old files.

Note that there is currently a way to change this behaviour in
the code in action.py, to allow files to be overwritten. However
there is no way this flag can be set through the browser interface
(yet).

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/dispatch/request.py
1
1
# IVLE - Informatics Virtual Learning Environment
2
 
# Copyright (C) 2007-2009 The University of Melbourne
 
2
# Copyright (C) 2007-2008 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: dispatch.request
18
19
# Author: Matt Giuca
19
 
 
20
 
"""
21
 
IVLE Request Object
22
 
 
23
 
Builds an IVLE request object from a mod_python request object.
24
 
See design notes/apps/dispatch.txt for a full specification of this request
25
 
object.
26
 
"""
27
 
 
28
 
try:
29
 
    import mod_python.Session
30
 
    import mod_python.Cookie
31
 
    import mod_python.util
32
 
except ImportError:
33
 
    # This needs to be importable from outside Apache.
34
 
    pass
 
20
# Date:   12/12/2007
 
21
 
 
22
# Builds an IVLE request object from a mod_python request object.
 
23
# See design notes/apps/dispatch.txt for a full specification of this request
 
24
# object.
 
25
 
 
26
import mod_python
 
27
from mod_python import (util, Session, Cookie)
35
28
 
36
29
import ivle.util
37
30
import ivle.conf
38
 
import ivle.database
39
 
from ivle.webapp.base.plugins import CookiePlugin
 
31
import plugins.console # XXX: Relies on www/ being in the Python path.
40
32
 
41
33
class Request:
42
34
    """An IVLE request object. This is presented to the IVLE apps as a way of
56
48
        user (read)
57
49
            User object. Details of the user who is currently logged in, or
58
50
            None.
59
 
        store (read)
60
 
            storm.store.Store instance. Holds a database transaction open,
61
 
            which is available for the entire lifetime of the request.
62
51
        hostname (read)
63
52
            String. Hostname the server is running on.
64
53
        headers_in (read)
78
67
        location (write)
79
68
            String. Response "Location" header value. Used with HTTP redirect
80
69
            responses.
 
70
        title (write)
 
71
            String. HTML page title. Used if write_html_head_foot is True, in
 
72
            the HTML title element text.
81
73
        styles (write)
82
74
            List of strings. Write a list of URLs to CSS files here, and they
83
75
            will be incorporated as <link rel="stylesheet" type="text/css">
96
88
            in the head, if write_html_head_foot is True.
97
89
            This is the propper way to specify functions that need to run at 
98
90
            page load time.
 
91
        write_html_head_foot (write)
 
92
            Boolean. If True, dispatch assumes that this is an XHTML page, and
 
93
            will immediately write a full HTML head, open the body element,
 
94
            and write heading contents to the page, before any bytes are
 
95
            written. It will then write footer contents and close the body and
 
96
            html elements at the end of execution.  
 
97
 
 
98
            This value should be set to true by all applications for all HTML
 
99
            output (unless there is a good reason, eg. exec). The
 
100
            applications should therefore output HTML content assuming that
 
101
            it will be written inside the body tag. Do not write opening or
 
102
            closing <html> or <body> tags.
99
103
    """
100
104
 
101
105
    # Special code for an OK response.
154
158
    HTTP_INSUFFICIENT_STORAGE         = 507
155
159
    HTTP_NOT_EXTENDED                 = 510
156
160
 
157
 
    def __init__(self, req):
 
161
    def __init__(self, req, write_html_head):
158
162
        """Builds an IVLE request object from a mod_python request object.
159
163
        This results in an object with all of the necessary methods and
160
164
        additional fields.
161
165
 
162
166
        req: A mod_python request object.
 
167
        write_html_head: Function which is called when writing the automatic
 
168
            HTML header. Accepts a single argument, the IVLE request object.
163
169
        """
164
170
 
165
171
        # Methods are mostly wrappers around the Apache request object
166
172
        self.apache_req = req
 
173
        self.func_write_html_head = write_html_head
167
174
        self.headers_written = False
168
175
 
169
176
        # Determine if the browser used the public host name to make the
185
192
        self.headers_in = req.headers_in
186
193
        self.headers_out = req.headers_out
187
194
 
188
 
        # Open a database connection and transaction, keep it around for users
189
 
        # of the Request object to use
190
 
        self.store = ivle.database.get_store()
191
 
 
192
195
        # Default values for the output members
193
196
        self.status = Request.HTTP_OK
194
197
        self.content_type = None        # Use Apache's default
195
198
        self.location = None
 
199
        self.title = None     # Will be set by dispatch before passing to app
196
200
        self.styles = []
197
201
        self.scripts = []
198
202
        self.scripts_init = []
 
203
        self.write_html_head_foot = False
199
204
        # In some cases we don't want the template JS (such as the username
200
205
        # and public FQDN) in the output HTML. In that case, set this to 0.
201
206
        self.write_javascript_settings = True
202
207
        self.got_common_vars = False
203
208
 
204
 
    def __del__(self):
205
 
        """Cleanup."""
206
 
        self.store.close()
207
 
 
208
209
    def __writeheaders(self):
209
210
        """Writes out the HTTP and HTML headers before any real data is
210
211
        written."""
211
212
        self.headers_written = True
 
213
        
 
214
        # app is the App object for the chosen app
 
215
        try:
 
216
            app = ivle.conf.apps.app_url[self.app]
 
217
        except KeyError:
 
218
            app = None
 
219
 
 
220
        # Write any final modifications to header content
 
221
        if app and app.useconsole and self.user:
 
222
            plugins.console.insert_scripts_styles(self.scripts, self.styles, \
 
223
                self.scripts_init)
212
224
 
213
225
        # Prepare the HTTP and HTML headers before the first write is made
214
226
        if self.content_type != None:
216
228
        self.apache_req.status = self.status
217
229
        if self.location != None:
218
230
            self.apache_req.headers_out['Location'] = self.location
 
231
        if self.write_html_head_foot:
 
232
            # Write the HTML header, pass "self" (request object)
 
233
            self.func_write_html_head(self)
219
234
 
220
235
    def ensure_headers_written(self):
221
236
        """Writes out the HTTP and HTML headers if they haven't already been
241
256
    def logout(self):
242
257
        """Log out the current user by destroying the session state.
243
258
        Then redirect to the top-level IVLE page."""
 
259
        # List of cookies that IVLE uses (to be removed at logout)
 
260
        ivle_cookies = ["ivleforumcookie", "clipboard"]
 
261
        
244
262
        if hasattr(self, 'session'):
245
263
            self.session.invalidate()
246
264
            self.session.delete()
247
265
            # Invalidates all IVLE cookies
248
 
            all_cookies = mod_python.Cookie.get_cookies(self)
249
 
 
250
 
            # Create cookies for plugins that might request them.
251
 
            for plugin in self.config.plugin_index[CookiePlugin]:
252
 
                for cookie in plugin.cookies:
253
 
                    self.add_cookie(mod_python.Cookie.Cookie(cookie, '',
254
 
                                                    expires=1, path='/'))
 
266
            all_cookies = Cookie.get_cookies(self)
 
267
            for cookie in all_cookies:
 
268
                if cookie in ivle_cookies:
 
269
                    self.add_cookie(Cookie.Cookie(cookie,'',expires=1,path='/'))
255
270
        self.throw_redirect(ivle.util.make_path('')) 
256
271
 
257
272
 
273
288
        else:
274
289
            return self.apache_req.read(len)
275
290
 
 
291
    def throw_error(self, httpcode, message=None):
 
292
        """Writes out an HTTP error of the specified code. Raises an exception
 
293
        which is caught by the dispatch or web server, so any code following
 
294
        this call will not be executed.
 
295
 
 
296
        httpcode: An HTTP response status code. Pass a constant from the
 
297
        Request class.
 
298
        """
 
299
        raise ivle.util.IVLEError(httpcode, message)
 
300
 
276
301
    def throw_redirect(self, location):
277
302
        """Writes out an HTTP redirect to the specified URL. Raises an
278
303
        exception which is caught by the dispatch or web server, so any
281
306
        httpcode: An HTTP response status code. Pass a constant from the
282
307
        Request class.
283
308
        """
284
 
        # Note: location may be a unicode, but it MUST only have ASCII
285
 
        # characters (non-ascii characters should be URL-encoded).
286
 
        mod_python.util.redirect(self.apache_req, location.encode("ascii"))
 
309
        mod_python.util.redirect(self.apache_req, location)
287
310
 
288
311
    def add_cookie(self, cookie, value=None, **attributes):
289
312
        """Inserts a cookie into this request object's headers."""
290
313
        if value is None:
291
 
            mod_python.Cookie.add_cookie(self.apache_req, cookie)
 
314
            Cookie.add_cookie(self.apache_req, cookie)
292
315
        else:
293
 
            mod_python.Cookie.add_cookie(self.apache_req, cookie, value, **attributes)
 
316
            Cookie.add_cookie(self.apache_req, cookie, value, **attributes)
294
317
 
295
318
    def get_session(self):
296
319
        """Returns a mod_python Session object for this request.
298
321
        interface if porting away from mod_python."""
299
322
        # Cache the session object and set the timeout to 24 hours.
300
323
        if not hasattr(self, 'session'):
301
 
            self.session = mod_python.Session.FileSession(self.apache_req,
 
324
            self.session = Session.FileSession(self.apache_req,
302
325
                                               timeout = 60 * 60 * 24)
303
326
        return self.session
304
327
 
308
331
        interface if porting away from mod_python."""
309
332
        # Cache the fieldstorage object
310
333
        if not hasattr(self, 'fields'):
311
 
            self.fields = mod_python.util.FieldStorage(self.apache_req)
 
334
            self.fields = util.FieldStorage(self.apache_req)
312
335
        return self.fields
313
336
 
314
337
    def get_cgi_environ(self):