1

# coding: utf-8

     2

"""

     3

    Generic controller base classes.

     4

     5

    respond(Request) -> Response

     6

"""

     7

     8

import werkzeug

     9

from werkzeug import Response

    10

    11

from svv import html, pdf

    12

from svv.html import tags

    13

    14

class AppHandler (object):

    15

    """

    16

        Per-request handler type, containing the request context and implementing the response.

    17

    18

        Works on a generic level, i.e. WSGI/Werkzeug URL-mapped request in, response out.

    19

    """

    20

    21

    def __init__ (self, app, request, urlmap) :

    22

        """

    23

            Initialize for processing the given Request, to prepare for action-method later on

    24

    25

                app     - the global Application state

    26

                request - the request state

    27

                urlmap  - the URL map we were matched through

    28

        """

    29

    30

        self.app = app

    31

        self.request = request

    32

        self.urlmap = urlmap

    33

    34

    def url_for (self, endpoint, **values) :

    35

        """

    36

            Return an URL for the given endpoint, applying the given URL-embedded values

    37

        """

    38

    39

        return self.urlmap.build(endpoint, values)

    40

    41

    def redirect_for (self, endpoint, **values) :

    42

        """

    43

            Return a Response that will redirect the client to the given endpoint.

    44

        """

    45

    46

        return werkzeug.redirect(self.url_for(endpoint, **values))

    47

    48

    @property

    49

    def POST (self) :

    50

        """

    51

            Access request's POST data

    52

        """

    53

    54

        # MultiDict from werkzeug.Request

    55

        return self.request.form

    56

    57

    def respond (self, url_values) :

    58

        """

    59

            Handle request that was mapped to ourselves via the URL routing, using given dict of values from URL.

    60

        """

    61

    62

        raise NotImplementedError()

    63

    64

class PageHandler (AppHandler) :

    65

    """

    66

        Specialized AppHandler for normal HTML page views.

    67

    68

        Renders the layout template and HTML.

    69

    """

    70

    71

    def render_content (self, **args) :

    72

        """

    73

            Render and return HTML for page content.

    74

    75

            XXX: must be HTML object, support just text?

    76

        """

    77

    78

        raise NotImplementedError()

    79

    80

    def render_layout (self, content) :

    81

        """

    82

            Render the page layout for the given content block.

    83

        """

    84

    85

        # XXX: layout template, should be somewhere far away

    86

        title = "Index"

    87

        css = [

    88

                "/static/layout.css", 

    89

                "/static/style.css", 

    90

                "/static/forms.css",

    91

                "/static/tables.css",

    92

    93

                "/static/treelist.css",

    94

    95

                "/static/jquery-ui/jquery-ui.css",

    96

        ]

    97

        scripts = [

    98

                "/static/js/jquery.js",

    99

                "/static/js/jquery-ui.min.js",  # fairly big

   100

                "/static/js/jquery-ui-timepicker.js",

   101

                "/static/js/jquery.ui.datepicker-fi.js",

   102

   103

                "/static/js/forms.js",

   104

   105

                #"/static/js/prototype.js", 

   106

                #"/static/js/scriptaculous/scriptaculous.js", 

   107

                #"/static/js/treelist.js"

   108

        ]

   109

   110

        head = (

   111

            tags.title(title),

   112

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

   113

            # XXX: script can't self-close >_<

   114

            (tags.script(src=src)(" ") for src in scripts),

   115

        )

   116

   117

        # XXX: silly circular-import hack for urls

   118

        #      it's not sustainable for a base class to referr to its subclasses at define time

   119

        from svv import urls

   120

   121

        header = ("Foo List")

   122

        nav = [tags.ul(tags.li(tags.a(href='#')(name)) for name in ['Nav A', 'Nav B', 'Nav C'])]

   123

        menu = [tags.ul(tags.li(tags.a(href=url)(name)) for name, url in [

   124

            ("Etusivu",     self.url_for(urls.Index)),

   125

            ("Uusi tilaus", self.url_for(urls.NewOrderView)),

   126

            ("Tilaukset",   self.url_for(urls.OrdersView)),

   127

            ("Tilaajat",    self.url_for(urls.CustomersView)),

   128

        ])]

   129

        footer = ("Copyright?")

   130

   131

        layout = (

   132

            tags.div(id='header')(header),

   133

            tags.div(id='container')(

   134

                tags.div(id='menu')(menu),

   136

                tags.div(id='content')(content),

   137

            ),

   138

            tags.div(id='footer')(footer),

   139

        )

   140

   141

        # perform the actual rendering (run generators etc.)

   142

        return unicode(html.document(head, layout))

   143

   144

    def render (self, **url_values) :

   145

        """

   146

            Render full page HTML

   147

        """

   148

   149

        # render page content

   150

        content = self.render_content(**url_values)

   151

   152

        # render into layout

   153

        response = self.render_layout(content)

   154

   155

        # ok

   156

        return response

   157

   158

    def respond (self, url_values) :

   159

        """

   160

            Build and return a response from the following steps:

   161

   162

            * process() 

   163

            * render() -> render_content() as HTML

   164

        """

   165

   166

        # process e.g. POST data for e.g. redirect

   167

        response = self.process(**url_values)

   168

   169

        if not response :

   170

            # render page HTML

   171

            html = self.render(**url_values)

   172

   173

            # response object

   174

            # XXX: unicode?

   175

            return Response(html, mimetype='text/html')

   176

   177

        # ok

   178

        return response

   179

   180

    def process (self, **args) :

   181

        """

   182

            Process incoming POST data, optionally returning a redirect response.

   183

        """

   184

   185

        # default to ignore

   186

        pass

   187

   188

class DocumentHandler (AppHandler) :

   189

    """

   190

        PDF generation/export

   191

    """

   192

   193

    def respond (self, url_values) :

   194

        """

   195

            Generate the document, and return it as a .pdf file, with the filename generated from the document's title.

   196

        """

   197

   198

        pdf_file = self.generate(**url_values)

   199

   200

        # file wrapper

   201

        # XXX: is this any use at all for StringIO?

   202

        pdf_file = werkzeug.wrap_file(self.request.environ, pdf_file)

   203

   204

        # respond with file wrapper

   205

        return Response(pdf_file, mimetype='application/pdf', direct_passthrough=True)

   206

   207

    def generate (self, **url_values) :

   208

        """

   209

            Generate the PDF document as a file-like object.

   210

        """

   211

   212

        document, elements = self.generate_document(**url_values)

   213

   214

        # render and return StringIO

   215

        return document.render_buf(elements)

   216

   217

    def generate_document (self, **url_values) :

   218

        """

   219

            Return the

   220

                (DocumentTemplate, elements)

   221

            to generate the PDF document from.

   222

        """

   223

   224

        raise NotImplementedError()

   225

   226

### XXX: random test controllers

   227

   228

class Index (PageHandler) :

   229

    DATA = (

   230

        (100, "Top A", []),

   231

        (200, "Top B", [

   232

            (210, "Mid BA", [

   233

                (211, "Sub BAA", []),

   234

                (212, "Sub BAB", []),

   235

            ]),

   236

            (220, "Mid BB", []),

   237

        ]),

   238

        (300, "Top C", [

   239

            (310, "Mid CA", []),

   240

            (320, "Mid CB", []),

   241

        ]),

   242

    )

   243

   244

    def render_content (self) :

   245

        # build data set

   246

        data = self.DATA

   247

   248

        def render_item (id, text, children) :

   249

            return tags.li(

   250

                tags.div(class_='item')(

   251

                    # item text

   252

                    tags.a(tags.input(type='checkbox', name_=id, checked=(

   253

                        'checked' if self.request.form.get(str(id)) else None

   254

                    )), text, class_='text'),

   255

                ),

   256

   257

                # children

   258

                tags.ul(render_item(*item) for item in children if item) if children else None,

   259

   260

                # 

   261

                class_=('more open' if children else None),

   262

            )

   263

   264

        # render it

   265

        return (

   266

            tags.h3("Item list"),

   267

            tags.form(action='.', method='post')(

   268

                tags.ul(class_='treelist')(render_item(*item) for item in data),

   269

                tags.input(type='submit'),

   270

            ),

   271

        )

   272

   273

   274