1

"""

     2

    WSGI Application with pvl.web.urls-mapped Handlers building pvl.web.html.

     3

"""

     4

     5

import werkzeug

     6

from werkzeug.wrappers import Request, Response

     7

from werkzeug.exceptions import HTTPException

     8

     9

import pvl.web.response

    10

    11

import logging; log = logging.getLogger('pvl.web.application')

    12

    13

class Application (object) :

    14

    """

    15

        Main wsgi entry point state.

    16

    """

    17

    18

    URLS = None

    19

    20

    # TODO: charset

    21

    22

    def __init__ (self, urls=None, layout=None) :

    23

        """

    24

                urls        - werkzeug.routing.Map -> Handler

    25

                layout      - template with {TITLE} and {HEAD} and {BODY}

    26

        """

    27

    28

        if not urls :

    29

            urls = self.URLS

    30

    31

        if not urls :

    32

            raise ValueError("No URLS/urls=... given")

    33

    34

        self.layout = layout

    35

        self.urls = urls

    36

    37

    def respond (self, request) :

    38

        """

    39

            Lookup Request -> web.Handler, params

    40

        """

    41

    42

        # bind to request

    43

        urls = self.urls.bind_to_environ(request)

    44

    45

        # lookup

    46

        handler, params = urls.match()

    47

    48

        # handler instance

    49

        handler = handler(self, request, urls, params)

    50

    51

        try :

    52

            # apply

    53

            return handler.respond()

    54

    55

        finally :

    56

            handler.cleanup()

    57

    58

    @Request.application

    59

    def __call__ (self, request) :

    60

        """

    61

            WSGI entry point, werkzeug Request -> Response

    62

        """

    63

    64

        try :

    65

            return self.respond(request)

    66

    67

        except HTTPException as ex :

    68

            return ex

    69

    70

from pvl.invoke import merge # XXX

    71

from pvl.web.html import tags as html

    72

    73

class Handler (object) :

    74

    """

    75

        Per-Request controller/view, containing the request context and generating the response.

    76

    """

    77

    78

    DOCTYPE = 'html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"'

    79

    HTML_XMLNS = 'http://www.w3.org/1999/xhtml'

    80

    HTML_LANG = None

    81

    82

    TITLE = None

    83

    STYLE = None

    84

    SCRIPT = None

    85

    CSS = (

    86

        #"/static/...css", 

    87

    )

    88

    JS = (

    89

        #"/static/....js"

    90

    )

    91

    92

    STATUS = 200

    93

    94

    def __init__ (self, app, request, urls, params) :

    95

        """

    96

            app     - wsgi.Application

    97

            request - werkzeug.Request

    98

            urls    - werkzeug.routing.Map.bind_to_environ()

    99

        """

   100

   101

        self.app = app

   102

        self.request = request

   103

        self.urls = urls

   104

        self.params = params

   105

   106

        self.init()

   107

   108

    def init (self) :

   109

        """

   110

            Initialize on request.

   111

        """

   112

   113

    def url (self, handler=None, **params) :

   114

        """

   115

            Return an URL for given endpoint, with parameters,

   116

        """

   117

   118

        if not handler :

   119

            # XXX: just generate a plain-relative '?foo=...' url instead?

   120

            handler = self.__class__

   121

            params = merge(self.params, params)

   122

   123

        return self.urls.build(handler, params)

   124

   125

    def status (self) :

   126

        """

   127

            Return HTTP status code for response.

   128

        """

   129

   130

        return self.STATUS

   131

   132

    def title (self) :

   133

        """

   134

            Render site/page title as text.

   135

        """

   136

   137

        return self.TITLE

   138

   139

    def render (self) :

   140

        """

   141

            Render page content (as <body>...</body>).

   142

        """

   143

   144

        raise NotImplementedError()

   145

   147

        """

   148

            Render page layout (as <html>).

   149

        """

   150

   151

        title = self.title()

   152

        head = html(

   153

                (

   154

                    html.link(rel='Stylesheet', type="text/css", href=src) for src in self.CSS

   155

                ), 

   156

                (

   157

                    html.script(src=src, type='text/javascript', _selfclosing=False) for src in self.JS

   158

                ),

   159

                html.style(type='text/css')(self.STYLE) if self.STYLE else None,

   160

                html.script(type='text/javascript')(self.SCRIPT) if self.SCRIPT else None,

   162

        )

   166

   167

        if not title :

   168

            raise Exception("%s: no page title!" % (self, ))

   169

   170

        if self.app.layout :

   171

            return self.app.layout.format(

   172

                TITLE   = unicode(title),

   173

                HEAD    = unicode(head),

   174

                BODY    = unicode(body),

   175

            )

   176

        else :

   177

            return html.document(html.html(

   178

                html.head(

   179

                    html.title(title),

   180

                    head,

   181

                ),

   182

                html.body(

   183

                    html.h1(title),

   184

                    body,

   185

                )

   186

            ), doctype=self.DOCTYPE, html_xmlns=self.HTML_XMLNS, html_lang=self.HTML_LANG)

   187

   188

    def response_file (self, file) :

   189

        """

   190

            Wrap a file for returning in a response with direct_passthrough=True.

   191

        """

   192

   193

        return werkzeug.wrap_file(self.request.environ, file)

   194

   195

    def process (self, **params) :

   196

        """

   197

            Process request args to build internal request state.

   198

        """

   199

   200

        pass

   201

   202

    def respond (self) :

   203

        """

   204

            Generate a response, or raise an HTTPException

   205

   206

            Does an HTML layout'd response per default.

   207

        """

   208

   209

        # returning e.g. redirect?

   210

        response = self.process(**self.params)

   211

   212

        if response :

   213

            return response

   214

   215

        # render as html per default

   216

        # XXX: might also be string?

   217

        text = unicode(self.render_html())

   218

   219

        return pvl.web.response.html(text,

   220

                status  = self.status(),

   221

        )

   222

   223

    def cleanup (self) :

   224

        """

   225

            After request processing. Do not fail :)

   226

        """

   227

   228

        pass