odoo web controller

标签：change   poco   request   control   rip   session   short   default   sse   

Routing

openerp.http.route(route=None, **kw)

Decorator marking the decorated method as being a handler for requests. The method must be part of a subclass of Controller.

Request

The request object is automatically set on openerp.http.request at the start of the request

class openerp.http.WebRequest(httprequest)

Parent class for all Odoo Web request types, mostly deals with initialization and setup of the request object (the dispatching itself has to be handled by the subclasses)

httprequest

the original werkzeug.wrappers.Request object provided to the request

params

Mapping of request parameters, not generally useful as they‘re provided directly to the handler method as keyword arguments

env

The Environment bound to current request. Raises a RuntimeError if the current requests is not bound to a database.

context

Mapping of context values for the current request

session

a OpenERPSession holding the HTTP session data for the current http session

cr

Cursor initialized for the current method call.

Accessing the cursor when the current request uses the none authentication will raise an exception.

debug

Indicates whether the current request is in "debug" mode

session_id

opaque identifier for the OpenERPSession instance of the current request

registry

The registry to the database linked to this request. Can be None if the current request uses the none authentication.

db

The database linked to this request. Can be None if the current request uses the none authentication.

httpsession

HTTP session data

class openerp.http.HttpRequest(*args)

Handler for the http request type.

matched routing parameters, query string parameters, form parameters and files are passed to the handler method as keyword arguments.

In case of name conflict, routing parameters have priority.

The handler method‘s result can be:

• a falsy value, in which case the HTTP response will be an HTTP 204 (No Content)
• a werkzeug Response object, which is returned as-is
• a str or unicode, will be wrapped in a Response object and interpreted as HTML

make_response(data, headers=None, cookies=None)

Helper for non-HTML responses, or HTML responses with custom response headers or cookies.

While handlers can just return the HTML markup of a page they want to send as a string if non-HTML data is returned they need to create a complete response object, or the returned data will not be correctly interpreted by the clients.

not_found(description=None)

Shortcut for a HTTP 404 (Not Found) response

render(template, qcontext=None, lazy=True, **kw)

Lazy render of a QWeb template.

The actual rendering of the given template will occur at then end of the dispatching. Meanwhile, the template and/or qcontext can be altered or even replaced by a static response.

class openerp.http.JsonRequest(*args)

Request handler for JSON-RPC 2 over HTTP

• method is ignored
• params must be a JSON object (not an array) and is passed as keyword arguments to the handler method
• the handler method‘s result is returned as JSON-RPC result and wrapped in the JSON-RPC Response

Sucessful request:

--> {"jsonrpc": "2.0",
     "method": "call",
     "params": {"context": {},
                "arg1": "val1" },
     "id": null}

Request producing a error:

--> {"jsonrpc": "2.0",
     "method": "call",
     "params": {"context": {},
                "arg1": "val1" },
     "id": null}

Response

class openerp.http.Response(*args, **kw)

Response object passed through controller route chain.

In addition to the werkzeug.wrappers.Response parameters, this class‘s constructor can take the following additional parameters for QWeb Lazy Rendering.

these attributes are available as parameters on the Response object and can be altered at any time before rendering

Also exposes all the attributes and methods of werkzeug.wrappers.Response.

render()

Renders the Response‘s template, returns the result

flatten()

Forces the rendering of the response‘s template, sets the result as response body and unsets template

Controllers

Controllers need to provide extensibility, much like Model, but can‘t use the same mechanism as the pre-requisites (a database with loaded modules) may not be available yet (e.g. no database created, or no database selected).

Controllers thus provide their own extension mechanism, separate from that of models:

Controllers are created by inheriting from

class openerp.http.Controller

and defining methods decorated with route():

class MyController(openerp.http.Controller):
    @route(‘/some_url‘, auth=‘public‘)
    def handler(self):
        return stuff()

To override a controller, inherit from its class and override relevant methods, re-exposing them if necessary:

class Extension(MyController):
    @route()
    def handler(self):
        do_before()
        return super(Extension, self).handler()

• decorating with route() is necessary to keep the method (and route) visible: if the method is redefined without decorating, it will be "unpublished"

• the decorators of all methods are combined, if the overriding method‘s decorator has no argument all previous ones will be kept, any provided argument will override previously defined ones e.g.:

  class Restrict(MyController):
      @route(auth=‘user‘)
      def handler(self):
          return super(Restrict, self).handler()
  

  will change /some_url from public authentication to user (requiring a log-in)

odoo web controller

标签：change   poco   request   control   rip   session   short   default   sse   

原文地址：http://www.cnblogs.com/dancesir/p/7324936.html